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, 2010 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "linux-low.h"
25 #include <sys/param.h>
26 #include <sys/ptrace.h>
28 #include <sys/ioctl.h>
34 #include <sys/syscall.h>
38 #include <sys/types.h>
43 /* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
44 then ELFMAG0 will have been defined. If it didn't get included by
45 gdb_proc_service.h then including it will likely introduce a duplicate
46 definition of elf_fpregset_t. */
51 #define SPUFS_MAGIC 0x23c9b64e
54 #ifndef PTRACE_GETSIGINFO
55 # define PTRACE_GETSIGINFO 0x4202
56 # define PTRACE_SETSIGINFO 0x4203
63 /* If the system headers did not provide the constants, hard-code the normal
65 #ifndef PTRACE_EVENT_FORK
67 #define PTRACE_SETOPTIONS 0x4200
68 #define PTRACE_GETEVENTMSG 0x4201
70 /* options set using PTRACE_SETOPTIONS */
71 #define PTRACE_O_TRACESYSGOOD 0x00000001
72 #define PTRACE_O_TRACEFORK 0x00000002
73 #define PTRACE_O_TRACEVFORK 0x00000004
74 #define PTRACE_O_TRACECLONE 0x00000008
75 #define PTRACE_O_TRACEEXEC 0x00000010
76 #define PTRACE_O_TRACEVFORKDONE 0x00000020
77 #define PTRACE_O_TRACEEXIT 0x00000040
79 /* Wait extended result codes for the above trace options. */
80 #define PTRACE_EVENT_FORK 1
81 #define PTRACE_EVENT_VFORK 2
82 #define PTRACE_EVENT_CLONE 3
83 #define PTRACE_EVENT_EXEC 4
84 #define PTRACE_EVENT_VFORK_DONE 5
85 #define PTRACE_EVENT_EXIT 6
87 #endif /* PTRACE_EVENT_FORK */
89 /* We can't always assume that this flag is available, but all systems
90 with the ptrace event handlers also have __WALL, so it's safe to use
93 #define __WALL 0x40000000 /* Wait for any child. */
97 #define W_STOPCODE(sig) ((sig) << 8 | 0x7f)
101 #if !(defined(__UCLIBC_HAS_MMU__) || defined(__ARCH_HAS_MMU__))
106 /* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol
107 representation of the thread ID.
109 ``all_lwps'' is keyed by the process ID - which on Linux is (presently)
110 the same as the LWP ID.
112 ``all_processes'' is keyed by the "overall process ID", which
113 GNU/Linux calls tgid, "thread group ID". */
115 struct inferior_list all_lwps
;
117 /* A list of all unknown processes which receive stop signals. Some other
118 process will presumably claim each of these as forked children
121 struct inferior_list stopped_pids
;
123 /* FIXME this is a bit of a hack, and could be removed. */
124 int stopping_threads
;
126 /* FIXME make into a target method? */
127 int using_threads
= 1;
129 /* This flag is true iff we've just created or attached to our first
130 inferior but it has not stopped yet. As soon as it does, we need
131 to call the low target's arch_setup callback. Doing this only on
132 the first inferior avoids reinializing the architecture on every
133 inferior, and avoids messing with the register caches of the
134 already running inferiors. NOTE: this assumes all inferiors under
135 control of gdbserver have the same architecture. */
136 static int new_inferior
;
138 static void linux_resume_one_lwp (struct lwp_info
*lwp
,
139 int step
, int signal
, siginfo_t
*info
);
140 static void linux_resume (struct thread_resume
*resume_info
, size_t n
);
141 static void stop_all_lwps (void);
142 static int linux_wait_for_event (ptid_t ptid
, int *wstat
, int options
);
143 static int check_removed_breakpoint (struct lwp_info
*event_child
);
144 static void *add_lwp (ptid_t ptid
);
145 static int linux_stopped_by_watchpoint (void);
146 static void mark_lwp_dead (struct lwp_info
*lwp
, int wstat
);
147 static int linux_core_of_thread (ptid_t ptid
);
149 struct pending_signals
153 struct pending_signals
*prev
;
156 #define PTRACE_ARG3_TYPE long
157 #define PTRACE_XFER_TYPE long
159 #ifdef HAVE_LINUX_REGSETS
160 static char *disabled_regsets
;
161 static int num_regsets
;
164 /* The read/write ends of the pipe registered as waitable file in the
166 static int linux_event_pipe
[2] = { -1, -1 };
168 /* True if we're currently in async mode. */
169 #define target_is_async_p() (linux_event_pipe[0] != -1)
171 static void send_sigstop (struct inferior_list_entry
*entry
);
172 static void wait_for_sigstop (struct inferior_list_entry
*entry
);
174 /* Accepts an integer PID; Returns a string representing a file that
175 can be opened to get info for the child process.
176 Space for the result is malloc'd, caller must free. */
179 linux_child_pid_to_exec_file (int pid
)
183 name1
= xmalloc (MAXPATHLEN
);
184 name2
= xmalloc (MAXPATHLEN
);
185 memset (name2
, 0, MAXPATHLEN
);
187 sprintf (name1
, "/proc/%d/exe", pid
);
188 if (readlink (name1
, name2
, MAXPATHLEN
) > 0)
200 /* Return non-zero if HEADER is a 64-bit ELF file. */
203 elf_64_header_p (const Elf64_Ehdr
*header
)
205 return (header
->e_ident
[EI_MAG0
] == ELFMAG0
206 && header
->e_ident
[EI_MAG1
] == ELFMAG1
207 && header
->e_ident
[EI_MAG2
] == ELFMAG2
208 && header
->e_ident
[EI_MAG3
] == ELFMAG3
209 && header
->e_ident
[EI_CLASS
] == ELFCLASS64
);
212 /* Return non-zero if FILE is a 64-bit ELF file,
213 zero if the file is not a 64-bit ELF file,
214 and -1 if the file is not accessible or doesn't exist. */
217 elf_64_file_p (const char *file
)
222 fd
= open (file
, O_RDONLY
);
226 if (read (fd
, &header
, sizeof (header
)) != sizeof (header
))
233 return elf_64_header_p (&header
);
237 delete_lwp (struct lwp_info
*lwp
)
239 remove_thread (get_lwp_thread (lwp
));
240 remove_inferior (&all_lwps
, &lwp
->head
);
241 free (lwp
->arch_private
);
245 /* Add a process to the common process list, and set its private
248 static struct process_info
*
249 linux_add_process (int pid
, int attached
)
251 struct process_info
*proc
;
253 /* Is this the first process? If so, then set the arch. */
254 if (all_processes
.head
== NULL
)
257 proc
= add_process (pid
, attached
);
258 proc
->private = xcalloc (1, sizeof (*proc
->private));
260 if (the_low_target
.new_process
!= NULL
)
261 proc
->private->arch_private
= the_low_target
.new_process ();
266 /* Remove a process from the common process list,
267 also freeing all private data. */
270 linux_remove_process (struct process_info
*process
)
272 struct process_info_private
*priv
= process
->private;
274 free (priv
->arch_private
);
276 remove_process (process
);
279 /* Wrapper function for waitpid which handles EINTR, and emulates
280 __WALL for systems where that is not available. */
283 my_waitpid (int pid
, int *status
, int flags
)
288 fprintf (stderr
, "my_waitpid (%d, 0x%x)\n", pid
, flags
);
292 sigset_t block_mask
, org_mask
, wake_mask
;
295 wnohang
= (flags
& WNOHANG
) != 0;
296 flags
&= ~(__WALL
| __WCLONE
);
299 /* Block all signals while here. This avoids knowing about
300 LinuxThread's signals. */
301 sigfillset (&block_mask
);
302 sigprocmask (SIG_BLOCK
, &block_mask
, &org_mask
);
304 /* ... except during the sigsuspend below. */
305 sigemptyset (&wake_mask
);
309 /* Since all signals are blocked, there's no need to check
311 ret
= waitpid (pid
, status
, flags
);
314 if (ret
== -1 && out_errno
!= ECHILD
)
319 if (flags
& __WCLONE
)
321 /* We've tried both flavors now. If WNOHANG is set,
322 there's nothing else to do, just bail out. */
327 fprintf (stderr
, "blocking\n");
329 /* Block waiting for signals. */
330 sigsuspend (&wake_mask
);
336 sigprocmask (SIG_SETMASK
, &org_mask
, NULL
);
341 ret
= waitpid (pid
, status
, flags
);
342 while (ret
== -1 && errno
== EINTR
);
347 fprintf (stderr
, "my_waitpid (%d, 0x%x): status(%x), %d\n",
348 pid
, flags
, status
? *status
: -1, ret
);
354 /* Handle a GNU/Linux extended wait response. If we see a clone
355 event, we need to add the new LWP to our list (and not report the
356 trap to higher layers). */
359 handle_extended_wait (struct lwp_info
*event_child
, int wstat
)
361 int event
= wstat
>> 16;
362 struct lwp_info
*new_lwp
;
364 if (event
== PTRACE_EVENT_CLONE
)
367 unsigned long new_pid
;
368 int ret
, status
= W_STOPCODE (SIGSTOP
);
370 ptrace (PTRACE_GETEVENTMSG
, lwpid_of (event_child
), 0, &new_pid
);
372 /* If we haven't already seen the new PID stop, wait for it now. */
373 if (! pull_pid_from_list (&stopped_pids
, new_pid
))
375 /* The new child has a pending SIGSTOP. We can't affect it until it
376 hits the SIGSTOP, but we're already attached. */
378 ret
= my_waitpid (new_pid
, &status
, __WALL
);
381 perror_with_name ("waiting for new child");
382 else if (ret
!= new_pid
)
383 warning ("wait returned unexpected PID %d", ret
);
384 else if (!WIFSTOPPED (status
))
385 warning ("wait returned unexpected status 0x%x", status
);
388 ptrace (PTRACE_SETOPTIONS
, new_pid
, 0, PTRACE_O_TRACECLONE
);
390 ptid
= ptid_build (pid_of (event_child
), new_pid
, 0);
391 new_lwp
= (struct lwp_info
*) add_lwp (ptid
);
392 add_thread (ptid
, new_lwp
);
394 /* Either we're going to immediately resume the new thread
395 or leave it stopped. linux_resume_one_lwp is a nop if it
396 thinks the thread is currently running, so set this first
397 before calling linux_resume_one_lwp. */
398 new_lwp
->stopped
= 1;
400 /* Normally we will get the pending SIGSTOP. But in some cases
401 we might get another signal delivered to the group first.
402 If we do get another signal, be sure not to lose it. */
403 if (WSTOPSIG (status
) == SIGSTOP
)
405 if (! stopping_threads
)
406 linux_resume_one_lwp (new_lwp
, 0, 0, NULL
);
410 new_lwp
->stop_expected
= 1;
411 if (stopping_threads
)
413 new_lwp
->status_pending_p
= 1;
414 new_lwp
->status_pending
= status
;
417 /* Pass the signal on. This is what GDB does - except
418 shouldn't we really report it instead? */
419 linux_resume_one_lwp (new_lwp
, 0, WSTOPSIG (status
), NULL
);
422 /* Always resume the current thread. If we are stopping
423 threads, it will have a pending SIGSTOP; we may as well
425 linux_resume_one_lwp (event_child
, event_child
->stepping
, 0, NULL
);
429 /* This function should only be called if the process got a SIGTRAP.
430 The SIGTRAP could mean several things.
432 On i386, where decr_pc_after_break is non-zero:
433 If we were single-stepping this process using PTRACE_SINGLESTEP,
434 we will get only the one SIGTRAP (even if the instruction we
435 stepped over was a breakpoint). The value of $eip will be the
437 If we continue the process using PTRACE_CONT, we will get a
438 SIGTRAP when we hit a breakpoint. The value of $eip will be
439 the instruction after the breakpoint (i.e. needs to be
440 decremented). If we report the SIGTRAP to GDB, we must also
441 report the undecremented PC. If we cancel the SIGTRAP, we
442 must resume at the decremented PC.
444 (Presumably, not yet tested) On a non-decr_pc_after_break machine
445 with hardware or kernel single-step:
446 If we single-step over a breakpoint instruction, our PC will
447 point at the following instruction. If we continue and hit a
448 breakpoint instruction, our PC will point at the breakpoint
454 CORE_ADDR stop_pc
= (*the_low_target
.get_pc
) ();
456 if (! get_thread_lwp (current_inferior
)->stepping
)
457 stop_pc
-= the_low_target
.decr_pc_after_break
;
460 fprintf (stderr
, "stop pc is 0x%lx\n", (long) stop_pc
);
466 add_lwp (ptid_t ptid
)
468 struct lwp_info
*lwp
;
470 lwp
= (struct lwp_info
*) xmalloc (sizeof (*lwp
));
471 memset (lwp
, 0, sizeof (*lwp
));
475 if (the_low_target
.new_thread
!= NULL
)
476 lwp
->arch_private
= the_low_target
.new_thread ();
478 add_inferior_to_list (&all_lwps
, &lwp
->head
);
483 /* Start an inferior process and returns its pid.
484 ALLARGS is a vector of program-name and args. */
487 linux_create_inferior (char *program
, char **allargs
)
489 struct lwp_info
*new_lwp
;
493 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
499 perror_with_name ("fork");
503 ptrace (PTRACE_TRACEME
, 0, 0, 0);
505 #ifdef __SIGRTMIN /* Bionic doesn't use SIGRTMIN the way glibc does. */
506 signal (__SIGRTMIN
+ 1, SIG_DFL
);
511 execv (program
, allargs
);
513 execvp (program
, allargs
);
515 fprintf (stderr
, "Cannot exec %s: %s.\n", program
,
521 linux_add_process (pid
, 0);
523 ptid
= ptid_build (pid
, pid
, 0);
524 new_lwp
= add_lwp (ptid
);
525 add_thread (ptid
, new_lwp
);
526 new_lwp
->must_set_ptrace_flags
= 1;
531 /* Attach to an inferior process. */
534 linux_attach_lwp_1 (unsigned long lwpid
, int initial
)
537 struct lwp_info
*new_lwp
;
539 if (ptrace (PTRACE_ATTACH
, lwpid
, 0, 0) != 0)
543 /* If we fail to attach to an LWP, just warn. */
544 fprintf (stderr
, "Cannot attach to lwp %ld: %s (%d)\n", lwpid
,
545 strerror (errno
), errno
);
550 /* If we fail to attach to a process, report an error. */
551 error ("Cannot attach to lwp %ld: %s (%d)\n", lwpid
,
552 strerror (errno
), errno
);
556 /* NOTE/FIXME: This lwp might have not been the tgid. */
557 ptid
= ptid_build (lwpid
, lwpid
, 0);
560 /* Note that extracting the pid from the current inferior is
561 safe, since we're always called in the context of the same
562 process as this new thread. */
563 int pid
= pid_of (get_thread_lwp (current_inferior
));
564 ptid
= ptid_build (pid
, lwpid
, 0);
567 new_lwp
= (struct lwp_info
*) add_lwp (ptid
);
568 add_thread (ptid
, new_lwp
);
570 /* We need to wait for SIGSTOP before being able to make the next
571 ptrace call on this LWP. */
572 new_lwp
->must_set_ptrace_flags
= 1;
574 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
577 There are several cases to consider here:
579 1) gdbserver has already attached to the process and is being notified
580 of a new thread that is being created.
581 In this case we should ignore that SIGSTOP and resume the process.
582 This is handled below by setting stop_expected = 1.
584 2) This is the first thread (the process thread), and we're attaching
585 to it via attach_inferior.
586 In this case we want the process thread to stop.
587 This is handled by having linux_attach clear stop_expected after
589 ??? If the process already has several threads we leave the other
592 3) GDB is connecting to gdbserver and is requesting an enumeration of all
594 In this case we want the thread to stop.
595 FIXME: This case is currently not properly handled.
596 We should wait for the SIGSTOP but don't. Things work apparently
597 because enough time passes between when we ptrace (ATTACH) and when
598 gdb makes the next ptrace call on the thread.
600 On the other hand, if we are currently trying to stop all threads, we
601 should treat the new thread as if we had sent it a SIGSTOP. This works
602 because we are guaranteed that the add_lwp call above added us to the
603 end of the list, and so the new thread has not yet reached
604 wait_for_sigstop (but will). */
605 if (! stopping_threads
)
606 new_lwp
->stop_expected
= 1;
610 linux_attach_lwp (unsigned long lwpid
)
612 linux_attach_lwp_1 (lwpid
, 0);
616 linux_attach (unsigned long pid
)
618 struct lwp_info
*lwp
;
620 linux_attach_lwp_1 (pid
, 1);
622 linux_add_process (pid
, 1);
626 /* Don't ignore the initial SIGSTOP if we just attached to this
627 process. It will be collected by wait shortly. */
628 lwp
= (struct lwp_info
*) find_inferior_id (&all_lwps
,
629 ptid_build (pid
, pid
, 0));
630 lwp
->stop_expected
= 0;
643 second_thread_of_pid_p (struct inferior_list_entry
*entry
, void *args
)
645 struct counter
*counter
= args
;
647 if (ptid_get_pid (entry
->id
) == counter
->pid
)
649 if (++counter
->count
> 1)
657 last_thread_of_process_p (struct thread_info
*thread
)
659 ptid_t ptid
= ((struct inferior_list_entry
*)thread
)->id
;
660 int pid
= ptid_get_pid (ptid
);
661 struct counter counter
= { pid
, 0 };
663 return (find_inferior (&all_threads
,
664 second_thread_of_pid_p
, &counter
) == NULL
);
667 /* Kill the inferior lwp. */
670 linux_kill_one_lwp (struct inferior_list_entry
*entry
, void *args
)
672 struct thread_info
*thread
= (struct thread_info
*) entry
;
673 struct lwp_info
*lwp
= get_thread_lwp (thread
);
675 int pid
= * (int *) args
;
677 if (ptid_get_pid (entry
->id
) != pid
)
680 /* We avoid killing the first thread here, because of a Linux kernel (at
681 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
682 the children get a chance to be reaped, it will remain a zombie
685 if (lwpid_of (lwp
) == pid
)
688 fprintf (stderr
, "lkop: is last of process %s\n",
689 target_pid_to_str (entry
->id
));
693 /* If we're killing a running inferior, make sure it is stopped
694 first, as PTRACE_KILL will not work otherwise. */
696 send_sigstop (&lwp
->head
);
700 ptrace (PTRACE_KILL
, lwpid_of (lwp
), 0, 0);
702 /* Make sure it died. The loop is most likely unnecessary. */
703 pid
= linux_wait_for_event (lwp
->head
.id
, &wstat
, __WALL
);
704 } while (pid
> 0 && WIFSTOPPED (wstat
));
712 struct process_info
*process
;
713 struct lwp_info
*lwp
;
714 struct thread_info
*thread
;
718 process
= find_process_pid (pid
);
722 find_inferior (&all_threads
, linux_kill_one_lwp
, &pid
);
724 /* See the comment in linux_kill_one_lwp. We did not kill the first
725 thread in the list, so do so now. */
726 lwp
= find_lwp_pid (pid_to_ptid (pid
));
727 thread
= get_lwp_thread (lwp
);
730 fprintf (stderr
, "lk_1: killing lwp %ld, for pid: %d\n",
731 lwpid_of (lwp
), pid
);
733 /* If we're killing a running inferior, make sure it is stopped
734 first, as PTRACE_KILL will not work otherwise. */
736 send_sigstop (&lwp
->head
);
740 ptrace (PTRACE_KILL
, lwpid_of (lwp
), 0, 0);
742 /* Make sure it died. The loop is most likely unnecessary. */
743 lwpid
= linux_wait_for_event (lwp
->head
.id
, &wstat
, __WALL
);
744 } while (lwpid
> 0 && WIFSTOPPED (wstat
));
747 thread_db_free (process
, 0);
750 linux_remove_process (process
);
755 linux_detach_one_lwp (struct inferior_list_entry
*entry
, void *args
)
757 struct thread_info
*thread
= (struct thread_info
*) entry
;
758 struct lwp_info
*lwp
= get_thread_lwp (thread
);
759 int pid
= * (int *) args
;
761 if (ptid_get_pid (entry
->id
) != pid
)
764 /* If we're detaching from a running inferior, make sure it is
765 stopped first, as PTRACE_DETACH will not work otherwise. */
768 int lwpid
= lwpid_of (lwp
);
770 stopping_threads
= 1;
771 send_sigstop (&lwp
->head
);
773 /* If this detects a new thread through a clone event, the new
774 thread is appended to the end of the lwp list, so we'll
775 eventually detach from it. */
776 wait_for_sigstop (&lwp
->head
);
777 stopping_threads
= 0;
779 /* If LWP exits while we're trying to stop it, there's nothing
781 lwp
= find_lwp_pid (pid_to_ptid (lwpid
));
786 /* Make sure the process isn't stopped at a breakpoint that's
788 check_removed_breakpoint (lwp
);
790 /* If this process is stopped but is expecting a SIGSTOP, then make
791 sure we take care of that now. This isn't absolutely guaranteed
792 to collect the SIGSTOP, but is fairly likely to. */
793 if (lwp
->stop_expected
)
796 /* Clear stop_expected, so that the SIGSTOP will be reported. */
797 lwp
->stop_expected
= 0;
799 linux_resume_one_lwp (lwp
, 0, 0, NULL
);
800 linux_wait_for_event (lwp
->head
.id
, &wstat
, __WALL
);
803 /* Flush any pending changes to the process's registers. */
804 regcache_invalidate_one ((struct inferior_list_entry
*)
805 get_lwp_thread (lwp
));
807 /* Finally, let it resume. */
808 ptrace (PTRACE_DETACH
, lwpid_of (lwp
), 0, 0);
815 any_thread_of (struct inferior_list_entry
*entry
, void *args
)
819 if (ptid_get_pid (entry
->id
) == *pid_p
)
826 linux_detach (int pid
)
828 struct process_info
*process
;
830 process
= find_process_pid (pid
);
835 thread_db_free (process
, 1);
839 (struct thread_info
*) find_inferior (&all_threads
, any_thread_of
, &pid
);
841 delete_all_breakpoints ();
842 find_inferior (&all_threads
, linux_detach_one_lwp
, &pid
);
843 linux_remove_process (process
);
851 struct process_info
*process
;
853 process
= find_process_pid (pid
);
858 ret
= my_waitpid (pid
, &status
, 0);
859 if (WIFEXITED (status
) || WIFSIGNALED (status
))
861 } while (ret
!= -1 || errno
!= ECHILD
);
864 /* Return nonzero if the given thread is still alive. */
866 linux_thread_alive (ptid_t ptid
)
868 struct lwp_info
*lwp
= find_lwp_pid (ptid
);
870 /* We assume we always know if a thread exits. If a whole process
871 exited but we still haven't been able to report it to GDB, we'll
872 hold on to the last lwp of the dead process. */
879 /* Return nonzero if this process stopped at a breakpoint which
880 no longer appears to be inserted. Also adjust the PC
881 appropriately to resume where the breakpoint used to be. */
883 check_removed_breakpoint (struct lwp_info
*event_child
)
886 struct thread_info
*saved_inferior
;
888 if (event_child
->pending_is_breakpoint
== 0)
892 fprintf (stderr
, "Checking for breakpoint in lwp %ld.\n",
893 lwpid_of (event_child
));
895 saved_inferior
= current_inferior
;
896 current_inferior
= get_lwp_thread (event_child
);
898 stop_pc
= get_stop_pc ();
900 /* If the PC has changed since we stopped, then we shouldn't do
901 anything. This happens if, for instance, GDB handled the
902 decr_pc_after_break subtraction itself. */
903 if (stop_pc
!= event_child
->pending_stop_pc
)
906 fprintf (stderr
, "Ignoring, PC was changed. Old PC was 0x%08llx\n",
907 event_child
->pending_stop_pc
);
909 event_child
->pending_is_breakpoint
= 0;
910 current_inferior
= saved_inferior
;
914 /* If the breakpoint is still there, we will report hitting it. */
915 if ((*the_low_target
.breakpoint_at
) (stop_pc
))
918 fprintf (stderr
, "Ignoring, breakpoint is still present.\n");
919 current_inferior
= saved_inferior
;
924 fprintf (stderr
, "Removed breakpoint.\n");
926 /* For decr_pc_after_break targets, here is where we perform the
927 decrement. We go immediately from this function to resuming,
928 and can not safely call get_stop_pc () again. */
929 if (the_low_target
.set_pc
!= NULL
)
932 fprintf (stderr
, "Set pc to 0x%lx\n", (long) stop_pc
);
933 (*the_low_target
.set_pc
) (stop_pc
);
936 /* We consumed the pending SIGTRAP. */
937 event_child
->pending_is_breakpoint
= 0;
938 event_child
->status_pending_p
= 0;
939 event_child
->status_pending
= 0;
941 current_inferior
= saved_inferior
;
945 /* Return 1 if this lwp has an interesting status pending. This
946 function may silently resume an inferior lwp. */
948 status_pending_p (struct inferior_list_entry
*entry
, void *arg
)
950 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
951 ptid_t ptid
= * (ptid_t
*) arg
;
953 /* Check if we're only interested in events from a specific process
955 if (!ptid_equal (minus_one_ptid
, ptid
)
956 && ptid_get_pid (ptid
) != ptid_get_pid (lwp
->head
.id
))
959 if (lwp
->status_pending_p
&& !lwp
->suspended
)
960 if (check_removed_breakpoint (lwp
))
962 /* This thread was stopped at a breakpoint, and the breakpoint
963 is now gone. We were told to continue (or step...) all threads,
964 so GDB isn't trying to single-step past this breakpoint.
965 So instead of reporting the old SIGTRAP, pretend we got to
966 the breakpoint just after it was removed instead of just
967 before; resume the process. */
968 linux_resume_one_lwp (lwp
, 0, 0, NULL
);
972 return (lwp
->status_pending_p
&& !lwp
->suspended
);
976 same_lwp (struct inferior_list_entry
*entry
, void *data
)
978 ptid_t ptid
= *(ptid_t
*) data
;
981 if (ptid_get_lwp (ptid
) != 0)
982 lwp
= ptid_get_lwp (ptid
);
984 lwp
= ptid_get_pid (ptid
);
986 if (ptid_get_lwp (entry
->id
) == lwp
)
993 find_lwp_pid (ptid_t ptid
)
995 return (struct lwp_info
*) find_inferior (&all_lwps
, same_lwp
, &ptid
);
998 static struct lwp_info
*
999 linux_wait_for_lwp (ptid_t ptid
, int *wstatp
, int options
)
1002 int to_wait_for
= -1;
1003 struct lwp_info
*child
= NULL
;
1006 fprintf (stderr
, "linux_wait_for_lwp: %s\n", target_pid_to_str (ptid
));
1008 if (ptid_equal (ptid
, minus_one_ptid
))
1009 to_wait_for
= -1; /* any child */
1011 to_wait_for
= ptid_get_lwp (ptid
); /* this lwp only */
1017 ret
= my_waitpid (to_wait_for
, wstatp
, options
);
1018 if (ret
== 0 || (ret
== -1 && errno
== ECHILD
&& (options
& WNOHANG
)))
1021 perror_with_name ("waitpid");
1024 && (!WIFSTOPPED (*wstatp
)
1025 || (WSTOPSIG (*wstatp
) != 32
1026 && WSTOPSIG (*wstatp
) != 33)))
1027 fprintf (stderr
, "Got an event from %d (%x)\n", ret
, *wstatp
);
1029 child
= find_lwp_pid (pid_to_ptid (ret
));
1031 /* If we didn't find a process, one of two things presumably happened:
1032 - A process we started and then detached from has exited. Ignore it.
1033 - A process we are controlling has forked and the new child's stop
1034 was reported to us by the kernel. Save its PID. */
1035 if (child
== NULL
&& WIFSTOPPED (*wstatp
))
1037 add_pid_to_list (&stopped_pids
, ret
);
1040 else if (child
== NULL
)
1044 child
->pending_is_breakpoint
= 0;
1046 child
->last_status
= *wstatp
;
1048 /* Architecture-specific setup after inferior is running.
1049 This needs to happen after we have attached to the inferior
1050 and it is stopped for the first time, but before we access
1051 any inferior registers. */
1054 the_low_target
.arch_setup ();
1055 #ifdef HAVE_LINUX_REGSETS
1056 memset (disabled_regsets
, 0, num_regsets
);
1062 && WIFSTOPPED (*wstatp
)
1063 && the_low_target
.get_pc
!= NULL
)
1065 struct thread_info
*saved_inferior
= current_inferior
;
1068 current_inferior
= (struct thread_info
*)
1069 find_inferior_id (&all_threads
, child
->head
.id
);
1070 pc
= (*the_low_target
.get_pc
) ();
1071 fprintf (stderr
, "linux_wait_for_lwp: pc is 0x%lx\n", (long) pc
);
1072 current_inferior
= saved_inferior
;
1078 /* Wait for an event from child PID. If PID is -1, wait for any
1079 child. Store the stop status through the status pointer WSTAT.
1080 OPTIONS is passed to the waitpid call. Return 0 if no child stop
1081 event was found and OPTIONS contains WNOHANG. Return the PID of
1082 the stopped child otherwise. */
1085 linux_wait_for_event_1 (ptid_t ptid
, int *wstat
, int options
)
1088 struct lwp_info
*event_child
= NULL
;
1090 struct lwp_info
*requested_child
= NULL
;
1092 /* Check for a lwp with a pending status. */
1093 /* It is possible that the user changed the pending task's registers since
1094 it stopped. We correctly handle the change of PC if we hit a breakpoint
1095 (in check_removed_breakpoint); signals should be reported anyway. */
1097 if (ptid_equal (ptid
, minus_one_ptid
)
1098 || ptid_equal (pid_to_ptid (ptid_get_pid (ptid
)), ptid
))
1100 event_child
= (struct lwp_info
*)
1101 find_inferior (&all_lwps
, status_pending_p
, &ptid
);
1102 if (debug_threads
&& event_child
)
1103 fprintf (stderr
, "Got a pending child %ld\n", lwpid_of (event_child
));
1107 requested_child
= find_lwp_pid (ptid
);
1108 if (requested_child
->status_pending_p
1109 && !check_removed_breakpoint (requested_child
))
1110 event_child
= requested_child
;
1113 if (event_child
!= NULL
)
1116 fprintf (stderr
, "Got an event from pending child %ld (%04x)\n",
1117 lwpid_of (event_child
), event_child
->status_pending
);
1118 *wstat
= event_child
->status_pending
;
1119 event_child
->status_pending_p
= 0;
1120 event_child
->status_pending
= 0;
1121 current_inferior
= get_lwp_thread (event_child
);
1122 return lwpid_of (event_child
);
1125 /* We only enter this loop if no process has a pending wait status. Thus
1126 any action taken in response to a wait status inside this loop is
1127 responding as soon as we detect the status, not after any pending
1131 event_child
= linux_wait_for_lwp (ptid
, wstat
, options
);
1133 if ((options
& WNOHANG
) && event_child
== NULL
)
1136 if (event_child
== NULL
)
1137 error ("event from unknown child");
1139 current_inferior
= get_lwp_thread (event_child
);
1141 /* Check for thread exit. */
1142 if (! WIFSTOPPED (*wstat
))
1145 fprintf (stderr
, "LWP %ld exiting\n", lwpid_of (event_child
));
1147 /* If the last thread is exiting, just return. */
1148 if (last_thread_of_process_p (current_inferior
))
1151 fprintf (stderr
, "LWP %ld is last lwp of process\n",
1152 lwpid_of (event_child
));
1153 return lwpid_of (event_child
);
1156 delete_lwp (event_child
);
1160 current_inferior
= (struct thread_info
*) all_threads
.head
;
1162 fprintf (stderr
, "Current inferior is now %ld\n",
1163 lwpid_of (get_thread_lwp (current_inferior
)));
1167 current_inferior
= NULL
;
1169 fprintf (stderr
, "Current inferior is now <NULL>\n");
1172 /* If we were waiting for this particular child to do something...
1173 well, it did something. */
1174 if (requested_child
!= NULL
)
1175 return lwpid_of (event_child
);
1177 /* Wait for a more interesting event. */
1181 if (event_child
->must_set_ptrace_flags
)
1183 ptrace (PTRACE_SETOPTIONS
, lwpid_of (event_child
),
1184 0, PTRACE_O_TRACECLONE
);
1185 event_child
->must_set_ptrace_flags
= 0;
1188 if (WIFSTOPPED (*wstat
)
1189 && WSTOPSIG (*wstat
) == SIGSTOP
1190 && event_child
->stop_expected
)
1193 fprintf (stderr
, "Expected stop.\n");
1194 event_child
->stop_expected
= 0;
1195 linux_resume_one_lwp (event_child
, event_child
->stepping
, 0, NULL
);
1199 if (WIFSTOPPED (*wstat
) && WSTOPSIG (*wstat
) == SIGTRAP
1200 && *wstat
>> 16 != 0)
1202 handle_extended_wait (event_child
, *wstat
);
1206 /* If GDB is not interested in this signal, don't stop other
1207 threads, and don't report it to GDB. Just resume the
1208 inferior right away. We do this for threading-related
1209 signals as well as any that GDB specifically requested we
1210 ignore. But never ignore SIGSTOP if we sent it ourselves,
1211 and do not ignore signals when stepping - they may require
1212 special handling to skip the signal handler. */
1213 /* FIXME drow/2002-06-09: Get signal numbers from the inferior's
1215 if (WIFSTOPPED (*wstat
)
1216 && !event_child
->stepping
1218 #if defined (USE_THREAD_DB) && defined (__SIGRTMIN)
1219 (current_process ()->private->thread_db
!= NULL
1220 && (WSTOPSIG (*wstat
) == __SIGRTMIN
1221 || WSTOPSIG (*wstat
) == __SIGRTMIN
+ 1))
1224 (pass_signals
[target_signal_from_host (WSTOPSIG (*wstat
))]
1225 && (WSTOPSIG (*wstat
) != SIGSTOP
|| !stopping_threads
))))
1227 siginfo_t info
, *info_p
;
1230 fprintf (stderr
, "Ignored signal %d for LWP %ld.\n",
1231 WSTOPSIG (*wstat
), lwpid_of (event_child
));
1233 if (ptrace (PTRACE_GETSIGINFO
, lwpid_of (event_child
), 0, &info
) == 0)
1237 linux_resume_one_lwp (event_child
,
1238 event_child
->stepping
,
1239 WSTOPSIG (*wstat
), info_p
);
1243 /* If this event was not handled above, and is not a SIGTRAP, report
1245 if (!WIFSTOPPED (*wstat
) || WSTOPSIG (*wstat
) != SIGTRAP
)
1246 return lwpid_of (event_child
);
1248 /* If this target does not support breakpoints, we simply report the
1249 SIGTRAP; it's of no concern to us. */
1250 if (the_low_target
.get_pc
== NULL
)
1251 return lwpid_of (event_child
);
1253 stop_pc
= get_stop_pc ();
1255 /* bp_reinsert will only be set if we were single-stepping.
1256 Notice that we will resume the process after hitting
1257 a gdbserver breakpoint; single-stepping to/over one
1258 is not supported (yet). */
1259 if (event_child
->bp_reinsert
!= 0)
1262 fprintf (stderr
, "Reinserted breakpoint.\n");
1263 reinsert_breakpoint (event_child
->bp_reinsert
);
1264 event_child
->bp_reinsert
= 0;
1266 /* Clear the single-stepping flag and SIGTRAP as we resume. */
1267 linux_resume_one_lwp (event_child
, 0, 0, NULL
);
1271 bp_status
= check_breakpoints (stop_pc
);
1276 fprintf (stderr
, "Hit a gdbserver breakpoint.\n");
1278 /* We hit one of our own breakpoints. We mark it as a pending
1279 breakpoint, so that check_removed_breakpoint () will do the PC
1280 adjustment for us at the appropriate time. */
1281 event_child
->pending_is_breakpoint
= 1;
1282 event_child
->pending_stop_pc
= stop_pc
;
1284 /* We may need to put the breakpoint back. We continue in the event
1285 loop instead of simply replacing the breakpoint right away,
1286 in order to not lose signals sent to the thread that hit the
1287 breakpoint. Unfortunately this increases the window where another
1288 thread could sneak past the removed breakpoint. For the current
1289 use of server-side breakpoints (thread creation) this is
1290 acceptable; but it needs to be considered before this breakpoint
1291 mechanism can be used in more general ways. For some breakpoints
1292 it may be necessary to stop all other threads, but that should
1293 be avoided where possible.
1295 If breakpoint_reinsert_addr is NULL, that means that we can
1296 use PTRACE_SINGLESTEP on this platform. Uninsert the breakpoint,
1297 mark it for reinsertion, and single-step.
1299 Otherwise, call the target function to figure out where we need
1300 our temporary breakpoint, create it, and continue executing this
1303 /* NOTE: we're lifting breakpoints in non-stop mode. This
1304 is currently only used for thread event breakpoints, so
1305 it isn't that bad as long as we have PTRACE_EVENT_CLONE
1308 /* No need to reinsert. */
1309 linux_resume_one_lwp (event_child
, 0, 0, NULL
);
1310 else if (the_low_target
.breakpoint_reinsert_addr
== NULL
)
1312 event_child
->bp_reinsert
= stop_pc
;
1313 uninsert_breakpoint (stop_pc
);
1314 linux_resume_one_lwp (event_child
, 1, 0, NULL
);
1318 reinsert_breakpoint_by_bp
1319 (stop_pc
, (*the_low_target
.breakpoint_reinsert_addr
) ());
1320 linux_resume_one_lwp (event_child
, 0, 0, NULL
);
1327 fprintf (stderr
, "Hit a non-gdbserver breakpoint.\n");
1329 /* If we were single-stepping, we definitely want to report the
1330 SIGTRAP. Although the single-step operation has completed,
1331 do not clear clear the stepping flag yet; we need to check it
1332 in wait_for_sigstop. */
1333 if (event_child
->stepping
)
1334 return lwpid_of (event_child
);
1336 /* A SIGTRAP that we can't explain. It may have been a breakpoint.
1337 Check if it is a breakpoint, and if so mark the process information
1338 accordingly. This will handle both the necessary fiddling with the
1339 PC on decr_pc_after_break targets and suppressing extra threads
1340 hitting a breakpoint if two hit it at once and then GDB removes it
1341 after the first is reported. Arguably it would be better to report
1342 multiple threads hitting breakpoints simultaneously, but the current
1343 remote protocol does not allow this. */
1344 if ((*the_low_target
.breakpoint_at
) (stop_pc
))
1346 event_child
->pending_is_breakpoint
= 1;
1347 event_child
->pending_stop_pc
= stop_pc
;
1350 return lwpid_of (event_child
);
1358 linux_wait_for_event (ptid_t ptid
, int *wstat
, int options
)
1362 if (ptid_is_pid (ptid
))
1364 /* A request to wait for a specific tgid. This is not possible
1365 with waitpid, so instead, we wait for any child, and leave
1366 children we're not interested in right now with a pending
1367 status to report later. */
1368 wait_ptid
= minus_one_ptid
;
1377 event_pid
= linux_wait_for_event_1 (wait_ptid
, wstat
, options
);
1380 && ptid_is_pid (ptid
) && ptid_get_pid (ptid
) != event_pid
)
1382 struct lwp_info
*event_child
= find_lwp_pid (pid_to_ptid (event_pid
));
1384 if (! WIFSTOPPED (*wstat
))
1385 mark_lwp_dead (event_child
, *wstat
);
1388 event_child
->status_pending_p
= 1;
1389 event_child
->status_pending
= *wstat
;
1397 /* Wait for process, returns status. */
1400 linux_wait_1 (ptid_t ptid
,
1401 struct target_waitstatus
*ourstatus
, int target_options
)
1404 struct thread_info
*thread
= NULL
;
1405 struct lwp_info
*lwp
= NULL
;
1409 /* Translate generic target options into linux options. */
1411 if (target_options
& TARGET_WNOHANG
)
1415 ourstatus
->kind
= TARGET_WAITKIND_IGNORE
;
1417 /* If we were only supposed to resume one thread, only wait for
1418 that thread - if it's still alive. If it died, however - which
1419 can happen if we're coming from the thread death case below -
1420 then we need to make sure we restart the other threads. We could
1421 pick a thread at random or restart all; restarting all is less
1424 && !ptid_equal (cont_thread
, null_ptid
)
1425 && !ptid_equal (cont_thread
, minus_one_ptid
))
1427 thread
= (struct thread_info
*) find_inferior_id (&all_threads
,
1430 /* No stepping, no signal - unless one is pending already, of course. */
1433 struct thread_resume resume_info
;
1434 resume_info
.thread
= minus_one_ptid
;
1435 resume_info
.kind
= resume_continue
;
1436 resume_info
.sig
= 0;
1437 linux_resume (&resume_info
, 1);
1443 pid
= linux_wait_for_event (ptid
, &w
, options
);
1444 if (pid
== 0) /* only if TARGET_WNOHANG */
1447 lwp
= get_thread_lwp (current_inferior
);
1449 /* If we are waiting for a particular child, and it exited,
1450 linux_wait_for_event will return its exit status. Similarly if
1451 the last child exited. If this is not the last child, however,
1452 do not report it as exited until there is a 'thread exited' response
1453 available in the remote protocol. Instead, just wait for another event.
1454 This should be safe, because if the thread crashed we will already
1455 have reported the termination signal to GDB; that should stop any
1456 in-progress stepping operations, etc.
1458 Report the exit status of the last thread to exit. This matches
1459 LinuxThreads' behavior. */
1461 if (last_thread_of_process_p (current_inferior
))
1463 if (WIFEXITED (w
) || WIFSIGNALED (w
))
1465 int pid
= pid_of (lwp
);
1466 struct process_info
*process
= find_process_pid (pid
);
1468 #ifdef USE_THREAD_DB
1469 thread_db_free (process
, 0);
1472 linux_remove_process (process
);
1474 current_inferior
= NULL
;
1478 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
1479 ourstatus
->value
.integer
= WEXITSTATUS (w
);
1482 fprintf (stderr
, "\nChild exited with retcode = %x \n", WEXITSTATUS (w
));
1486 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
1487 ourstatus
->value
.sig
= target_signal_from_host (WTERMSIG (w
));
1490 fprintf (stderr
, "\nChild terminated with signal = %x \n", WTERMSIG (w
));
1494 return pid_to_ptid (pid
);
1499 if (!WIFSTOPPED (w
))
1503 /* In all-stop, stop all threads. Be careful to only do this if
1504 we're about to report an event to GDB. */
1508 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
1510 if (lwp
->suspended
&& WSTOPSIG (w
) == SIGSTOP
)
1512 /* A thread that has been requested to stop by GDB with vCont;t,
1513 and it stopped cleanly, so report as SIG0. The use of
1514 SIGSTOP is an implementation detail. */
1515 ourstatus
->value
.sig
= TARGET_SIGNAL_0
;
1517 else if (lwp
->suspended
&& WSTOPSIG (w
) != SIGSTOP
)
1519 /* A thread that has been requested to stop by GDB with vCont;t,
1520 but, it stopped for other reasons. Set stop_expected so the
1521 pending SIGSTOP is ignored and the LWP is resumed. */
1522 lwp
->stop_expected
= 1;
1523 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (w
));
1527 ourstatus
->value
.sig
= target_signal_from_host (WSTOPSIG (w
));
1531 fprintf (stderr
, "linux_wait ret = %s, %d, %d\n",
1532 target_pid_to_str (lwp
->head
.id
),
1534 ourstatus
->value
.sig
);
1536 return lwp
->head
.id
;
1539 /* Get rid of any pending event in the pipe. */
1541 async_file_flush (void)
1547 ret
= read (linux_event_pipe
[0], &buf
, 1);
1548 while (ret
>= 0 || (ret
== -1 && errno
== EINTR
));
1551 /* Put something in the pipe, so the event loop wakes up. */
1553 async_file_mark (void)
1557 async_file_flush ();
1560 ret
= write (linux_event_pipe
[1], "+", 1);
1561 while (ret
== 0 || (ret
== -1 && errno
== EINTR
));
1563 /* Ignore EAGAIN. If the pipe is full, the event loop will already
1564 be awakened anyway. */
1568 linux_wait (ptid_t ptid
,
1569 struct target_waitstatus
*ourstatus
, int target_options
)
1574 fprintf (stderr
, "linux_wait: [%s]\n", target_pid_to_str (ptid
));
1576 /* Flush the async file first. */
1577 if (target_is_async_p ())
1578 async_file_flush ();
1580 event_ptid
= linux_wait_1 (ptid
, ourstatus
, target_options
);
1582 /* If at least one stop was reported, there may be more. A single
1583 SIGCHLD can signal more than one child stop. */
1584 if (target_is_async_p ()
1585 && (target_options
& TARGET_WNOHANG
) != 0
1586 && !ptid_equal (event_ptid
, null_ptid
))
1592 /* Send a signal to an LWP. */
1595 kill_lwp (unsigned long lwpid
, int signo
)
1597 /* Use tkill, if possible, in case we are using nptl threads. If tkill
1598 fails, then we are not using nptl threads and we should be using kill. */
1602 static int tkill_failed
;
1609 ret
= syscall (__NR_tkill
, lwpid
, signo
);
1610 if (errno
!= ENOSYS
)
1617 return kill (lwpid
, signo
);
1621 send_sigstop (struct inferior_list_entry
*entry
)
1623 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
1629 pid
= lwpid_of (lwp
);
1631 /* If we already have a pending stop signal for this process, don't
1633 if (lwp
->stop_expected
)
1636 fprintf (stderr
, "Have pending sigstop for lwp %d\n", pid
);
1638 /* We clear the stop_expected flag so that wait_for_sigstop
1639 will receive the SIGSTOP event (instead of silently resuming and
1640 waiting again). It'll be reset below. */
1641 lwp
->stop_expected
= 0;
1646 fprintf (stderr
, "Sending sigstop to lwp %d\n", pid
);
1648 kill_lwp (pid
, SIGSTOP
);
1652 mark_lwp_dead (struct lwp_info
*lwp
, int wstat
)
1654 /* It's dead, really. */
1657 /* Store the exit status for later. */
1658 lwp
->status_pending_p
= 1;
1659 lwp
->status_pending
= wstat
;
1661 /* So that check_removed_breakpoint doesn't try to figure out if
1662 this is stopped at a breakpoint. */
1663 lwp
->pending_is_breakpoint
= 0;
1665 /* Prevent trying to stop it. */
1668 /* No further stops are expected from a dead lwp. */
1669 lwp
->stop_expected
= 0;
1673 wait_for_sigstop (struct inferior_list_entry
*entry
)
1675 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
1676 struct thread_info
*saved_inferior
;
1684 saved_inferior
= current_inferior
;
1685 if (saved_inferior
!= NULL
)
1686 saved_tid
= ((struct inferior_list_entry
*) saved_inferior
)->id
;
1688 saved_tid
= null_ptid
; /* avoid bogus unused warning */
1690 ptid
= lwp
->head
.id
;
1692 linux_wait_for_event (ptid
, &wstat
, __WALL
);
1694 /* If we stopped with a non-SIGSTOP signal, save it for later
1695 and record the pending SIGSTOP. If the process exited, just
1697 if (WIFSTOPPED (wstat
)
1698 && WSTOPSIG (wstat
) != SIGSTOP
)
1701 fprintf (stderr
, "LWP %ld stopped with non-sigstop status %06x\n",
1702 lwpid_of (lwp
), wstat
);
1704 /* Do not leave a pending single-step finish to be reported to
1705 the client. The client will give us a new action for this
1706 thread, possibly a continue request --- otherwise, the client
1707 would consider this pending SIGTRAP reported later a spurious
1709 if (WSTOPSIG (wstat
) == SIGTRAP
1711 && !linux_stopped_by_watchpoint ())
1714 fprintf (stderr
, " single-step SIGTRAP ignored\n");
1718 lwp
->status_pending_p
= 1;
1719 lwp
->status_pending
= wstat
;
1721 lwp
->stop_expected
= 1;
1723 else if (!WIFSTOPPED (wstat
))
1726 fprintf (stderr
, "Process %ld exited while stopping LWPs\n",
1729 /* Leave this status pending for the next time we're able to
1730 report it. In the mean time, we'll report this lwp as dead
1731 to GDB, so GDB doesn't try to read registers and memory from
1733 mark_lwp_dead (lwp
, wstat
);
1736 if (saved_inferior
== NULL
|| linux_thread_alive (saved_tid
))
1737 current_inferior
= saved_inferior
;
1741 fprintf (stderr
, "Previously current thread died.\n");
1745 /* We can't change the current inferior behind GDB's back,
1746 otherwise, a subsequent command may apply to the wrong
1748 current_inferior
= NULL
;
1752 /* Set a valid thread as current. */
1753 set_desired_inferior (0);
1759 stop_all_lwps (void)
1761 stopping_threads
= 1;
1762 for_each_inferior (&all_lwps
, send_sigstop
);
1763 for_each_inferior (&all_lwps
, wait_for_sigstop
);
1764 stopping_threads
= 0;
1767 /* Resume execution of the inferior process.
1768 If STEP is nonzero, single-step it.
1769 If SIGNAL is nonzero, give it that signal. */
1772 linux_resume_one_lwp (struct lwp_info
*lwp
,
1773 int step
, int signal
, siginfo_t
*info
)
1775 struct thread_info
*saved_inferior
;
1777 if (lwp
->stopped
== 0)
1780 /* If we have pending signals or status, and a new signal, enqueue the
1781 signal. Also enqueue the signal if we are waiting to reinsert a
1782 breakpoint; it will be picked up again below. */
1784 && (lwp
->status_pending_p
|| lwp
->pending_signals
!= NULL
1785 || lwp
->bp_reinsert
!= 0))
1787 struct pending_signals
*p_sig
;
1788 p_sig
= xmalloc (sizeof (*p_sig
));
1789 p_sig
->prev
= lwp
->pending_signals
;
1790 p_sig
->signal
= signal
;
1792 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
1794 memcpy (&p_sig
->info
, info
, sizeof (siginfo_t
));
1795 lwp
->pending_signals
= p_sig
;
1798 if (lwp
->status_pending_p
&& !check_removed_breakpoint (lwp
))
1801 saved_inferior
= current_inferior
;
1802 current_inferior
= get_lwp_thread (lwp
);
1805 fprintf (stderr
, "Resuming lwp %ld (%s, signal %d, stop %s)\n",
1806 lwpid_of (lwp
), step
? "step" : "continue", signal
,
1807 lwp
->stop_expected
? "expected" : "not expected");
1809 /* This bit needs some thinking about. If we get a signal that
1810 we must report while a single-step reinsert is still pending,
1811 we often end up resuming the thread. It might be better to
1812 (ew) allow a stack of pending events; then we could be sure that
1813 the reinsert happened right away and not lose any signals.
1815 Making this stack would also shrink the window in which breakpoints are
1816 uninserted (see comment in linux_wait_for_lwp) but not enough for
1817 complete correctness, so it won't solve that problem. It may be
1818 worthwhile just to solve this one, however. */
1819 if (lwp
->bp_reinsert
!= 0)
1822 fprintf (stderr
, " pending reinsert at %08lx", (long)lwp
->bp_reinsert
);
1824 fprintf (stderr
, "BAD - reinserting but not stepping.\n");
1827 /* Postpone any pending signal. It was enqueued above. */
1831 check_removed_breakpoint (lwp
);
1833 if (debug_threads
&& the_low_target
.get_pc
!= NULL
)
1835 CORE_ADDR pc
= (*the_low_target
.get_pc
) ();
1836 fprintf (stderr
, " resuming from pc 0x%lx\n", (long) pc
);
1839 /* If we have pending signals, consume one unless we are trying to reinsert
1841 if (lwp
->pending_signals
!= NULL
&& lwp
->bp_reinsert
== 0)
1843 struct pending_signals
**p_sig
;
1845 p_sig
= &lwp
->pending_signals
;
1846 while ((*p_sig
)->prev
!= NULL
)
1847 p_sig
= &(*p_sig
)->prev
;
1849 signal
= (*p_sig
)->signal
;
1850 if ((*p_sig
)->info
.si_signo
!= 0)
1851 ptrace (PTRACE_SETSIGINFO
, lwpid_of (lwp
), 0, &(*p_sig
)->info
);
1857 if (the_low_target
.prepare_to_resume
!= NULL
)
1858 the_low_target
.prepare_to_resume (lwp
);
1860 regcache_invalidate_one ((struct inferior_list_entry
*)
1861 get_lwp_thread (lwp
));
1864 lwp
->stepping
= step
;
1865 ptrace (step
? PTRACE_SINGLESTEP
: PTRACE_CONT
, lwpid_of (lwp
), 0, signal
);
1867 current_inferior
= saved_inferior
;
1870 /* ESRCH from ptrace either means that the thread was already
1871 running (an error) or that it is gone (a race condition). If
1872 it's gone, we will get a notification the next time we wait,
1873 so we can ignore the error. We could differentiate these
1874 two, but it's tricky without waiting; the thread still exists
1875 as a zombie, so sending it signal 0 would succeed. So just
1880 perror_with_name ("ptrace");
1884 struct thread_resume_array
1886 struct thread_resume
*resume
;
1890 /* This function is called once per thread. We look up the thread
1891 in RESUME_PTR, and mark the thread with a pointer to the appropriate
1894 This algorithm is O(threads * resume elements), but resume elements
1895 is small (and will remain small at least until GDB supports thread
1898 linux_set_resume_request (struct inferior_list_entry
*entry
, void *arg
)
1900 struct lwp_info
*lwp
;
1901 struct thread_info
*thread
;
1903 struct thread_resume_array
*r
;
1905 thread
= (struct thread_info
*) entry
;
1906 lwp
= get_thread_lwp (thread
);
1909 for (ndx
= 0; ndx
< r
->n
; ndx
++)
1911 ptid_t ptid
= r
->resume
[ndx
].thread
;
1912 if (ptid_equal (ptid
, minus_one_ptid
)
1913 || ptid_equal (ptid
, entry
->id
)
1914 || (ptid_is_pid (ptid
)
1915 && (ptid_get_pid (ptid
) == pid_of (lwp
)))
1916 || (ptid_get_lwp (ptid
) == -1
1917 && (ptid_get_pid (ptid
) == pid_of (lwp
))))
1919 lwp
->resume
= &r
->resume
[ndx
];
1924 /* No resume action for this thread. */
1931 /* Set *FLAG_P if this lwp has an interesting status pending. */
1933 resume_status_pending_p (struct inferior_list_entry
*entry
, void *flag_p
)
1935 struct lwp_info
*lwp
= (struct lwp_info
*) entry
;
1937 /* LWPs which will not be resumed are not interesting, because
1938 we might not wait for them next time through linux_wait. */
1939 if (lwp
->resume
== NULL
)
1942 /* If this thread has a removed breakpoint, we won't have any
1943 events to report later, so check now. check_removed_breakpoint
1944 may clear status_pending_p. We avoid calling check_removed_breakpoint
1945 for any thread that we are not otherwise going to resume - this
1946 lets us preserve stopped status when two threads hit a breakpoint.
1947 GDB removes the breakpoint to single-step a particular thread
1948 past it, then re-inserts it and resumes all threads. We want
1949 to report the second thread without resuming it in the interim. */
1950 if (lwp
->status_pending_p
)
1951 check_removed_breakpoint (lwp
);
1953 if (lwp
->status_pending_p
)
1954 * (int *) flag_p
= 1;
1959 /* This function is called once per thread. We check the thread's resume
1960 request, which will tell us whether to resume, step, or leave the thread
1961 stopped; and what signal, if any, it should be sent.
1963 For threads which we aren't explicitly told otherwise, we preserve
1964 the stepping flag; this is used for stepping over gdbserver-placed
1967 If pending_flags was set in any thread, we queue any needed
1968 signals, since we won't actually resume. We already have a pending
1969 event to report, so we don't need to preserve any step requests;
1970 they should be re-issued if necessary. */
1973 linux_resume_one_thread (struct inferior_list_entry
*entry
, void *arg
)
1975 struct lwp_info
*lwp
;
1976 struct thread_info
*thread
;
1978 int pending_flag
= * (int *) arg
;
1980 thread
= (struct thread_info
*) entry
;
1981 lwp
= get_thread_lwp (thread
);
1983 if (lwp
->resume
== NULL
)
1986 if (lwp
->resume
->kind
== resume_stop
)
1989 fprintf (stderr
, "suspending LWP %ld\n", lwpid_of (lwp
));
1994 fprintf (stderr
, "running -> suspending LWP %ld\n", lwpid_of (lwp
));
1997 send_sigstop (&lwp
->head
);
2004 fprintf (stderr
, "already stopped/suspended LWP %ld\n",
2007 fprintf (stderr
, "already stopped/not suspended LWP %ld\n",
2011 /* Make sure we leave the LWP suspended, so we don't try to
2012 resume it without GDB telling us to. FIXME: The LWP may
2013 have been stopped in an internal event that was not meant
2014 to be notified back to GDB (e.g., gdbserver breakpoint),
2015 so we should be reporting a stop event in that case
2020 /* For stop requests, we're done. */
2027 /* If this thread which is about to be resumed has a pending status,
2028 then don't resume any threads - we can just report the pending
2029 status. Make sure to queue any signals that would otherwise be
2030 sent. In all-stop mode, we do this decision based on if *any*
2031 thread has a pending status. */
2033 resume_status_pending_p (&lwp
->head
, &pending_flag
);
2038 fprintf (stderr
, "resuming LWP %ld\n", lwpid_of (lwp
));
2040 if (ptid_equal (lwp
->resume
->thread
, minus_one_ptid
)
2042 && lwp
->pending_is_breakpoint
)
2045 step
= (lwp
->resume
->kind
== resume_step
);
2047 linux_resume_one_lwp (lwp
, step
, lwp
->resume
->sig
, NULL
);
2052 fprintf (stderr
, "leaving LWP %ld stopped\n", lwpid_of (lwp
));
2054 /* If we have a new signal, enqueue the signal. */
2055 if (lwp
->resume
->sig
!= 0)
2057 struct pending_signals
*p_sig
;
2058 p_sig
= xmalloc (sizeof (*p_sig
));
2059 p_sig
->prev
= lwp
->pending_signals
;
2060 p_sig
->signal
= lwp
->resume
->sig
;
2061 memset (&p_sig
->info
, 0, sizeof (siginfo_t
));
2063 /* If this is the same signal we were previously stopped by,
2064 make sure to queue its siginfo. We can ignore the return
2065 value of ptrace; if it fails, we'll skip
2066 PTRACE_SETSIGINFO. */
2067 if (WIFSTOPPED (lwp
->last_status
)
2068 && WSTOPSIG (lwp
->last_status
) == lwp
->resume
->sig
)
2069 ptrace (PTRACE_GETSIGINFO
, lwpid_of (lwp
), 0, &p_sig
->info
);
2071 lwp
->pending_signals
= p_sig
;
2080 linux_resume (struct thread_resume
*resume_info
, size_t n
)
2083 struct thread_resume_array array
= { resume_info
, n
};
2085 find_inferior (&all_threads
, linux_set_resume_request
, &array
);
2087 /* If there is a thread which would otherwise be resumed, which
2088 has a pending status, then don't resume any threads - we can just
2089 report the pending status. Make sure to queue any signals
2090 that would otherwise be sent. In non-stop mode, we'll apply this
2091 logic to each thread individually. */
2094 find_inferior (&all_lwps
, resume_status_pending_p
, &pending_flag
);
2099 fprintf (stderr
, "Not resuming, pending status\n");
2101 fprintf (stderr
, "Resuming, no pending status\n");
2104 find_inferior (&all_threads
, linux_resume_one_thread
, &pending_flag
);
2107 #ifdef HAVE_LINUX_USRREGS
2110 register_addr (int regnum
)
2114 if (regnum
< 0 || regnum
>= the_low_target
.num_regs
)
2115 error ("Invalid register number %d.", regnum
);
2117 addr
= the_low_target
.regmap
[regnum
];
2122 /* Fetch one register. */
2124 fetch_register (int regno
)
2131 if (regno
>= the_low_target
.num_regs
)
2133 if ((*the_low_target
.cannot_fetch_register
) (regno
))
2136 regaddr
= register_addr (regno
);
2140 pid
= lwpid_of (get_thread_lwp (current_inferior
));
2141 size
= ((register_size (regno
) + sizeof (PTRACE_XFER_TYPE
) - 1)
2142 & - sizeof (PTRACE_XFER_TYPE
));
2143 buf
= alloca (size
);
2144 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
2147 *(PTRACE_XFER_TYPE
*) (buf
+ i
) =
2148 ptrace (PTRACE_PEEKUSER
, pid
, (PTRACE_ARG3_TYPE
) regaddr
, 0);
2149 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
2152 /* Warning, not error, in case we are attached; sometimes the
2153 kernel doesn't let us at the registers. */
2154 char *err
= strerror (errno
);
2155 char *msg
= alloca (strlen (err
) + 128);
2156 sprintf (msg
, "reading register %d: %s", regno
, err
);
2162 if (the_low_target
.supply_ptrace_register
)
2163 the_low_target
.supply_ptrace_register (regno
, buf
);
2165 supply_register (regno
, buf
);
2170 /* Fetch all registers, or just one, from the child process. */
2172 usr_fetch_inferior_registers (int regno
)
2175 for (regno
= 0; regno
< the_low_target
.num_regs
; regno
++)
2176 fetch_register (regno
);
2178 fetch_register (regno
);
2181 /* Store our register values back into the inferior.
2182 If REGNO is -1, do this for all registers.
2183 Otherwise, REGNO specifies which register (so we can save time). */
2185 usr_store_inferior_registers (int regno
)
2194 if (regno
>= the_low_target
.num_regs
)
2197 if ((*the_low_target
.cannot_store_register
) (regno
) == 1)
2200 regaddr
= register_addr (regno
);
2204 size
= (register_size (regno
) + sizeof (PTRACE_XFER_TYPE
) - 1)
2205 & - sizeof (PTRACE_XFER_TYPE
);
2206 buf
= alloca (size
);
2207 memset (buf
, 0, size
);
2209 if (the_low_target
.collect_ptrace_register
)
2210 the_low_target
.collect_ptrace_register (regno
, buf
);
2212 collect_register (regno
, buf
);
2214 pid
= lwpid_of (get_thread_lwp (current_inferior
));
2215 for (i
= 0; i
< size
; i
+= sizeof (PTRACE_XFER_TYPE
))
2218 ptrace (PTRACE_POKEUSER
, pid
, (PTRACE_ARG3_TYPE
) regaddr
,
2219 *(PTRACE_XFER_TYPE
*) (buf
+ i
));
2222 /* At this point, ESRCH should mean the process is
2223 already gone, in which case we simply ignore attempts
2224 to change its registers. See also the related
2225 comment in linux_resume_one_lwp. */
2229 if ((*the_low_target
.cannot_store_register
) (regno
) == 0)
2231 char *err
= strerror (errno
);
2232 char *msg
= alloca (strlen (err
) + 128);
2233 sprintf (msg
, "writing register %d: %s",
2239 regaddr
+= sizeof (PTRACE_XFER_TYPE
);
2243 for (regno
= 0; regno
< the_low_target
.num_regs
; regno
++)
2244 usr_store_inferior_registers (regno
);
2246 #endif /* HAVE_LINUX_USRREGS */
2250 #ifdef HAVE_LINUX_REGSETS
2253 regsets_fetch_inferior_registers ()
2255 struct regset_info
*regset
;
2256 int saw_general_regs
= 0;
2259 regset
= target_regsets
;
2261 pid
= lwpid_of (get_thread_lwp (current_inferior
));
2262 while (regset
->size
>= 0)
2267 if (regset
->size
== 0 || disabled_regsets
[regset
- target_regsets
])
2273 buf
= xmalloc (regset
->size
);
2275 res
= ptrace (regset
->get_request
, pid
, 0, buf
);
2277 res
= ptrace (regset
->get_request
, pid
, buf
, 0);
2283 /* If we get EIO on a regset, do not try it again for
2285 disabled_regsets
[regset
- target_regsets
] = 1;
2292 sprintf (s
, "ptrace(regsets_fetch_inferior_registers) PID=%d",
2297 else if (regset
->type
== GENERAL_REGS
)
2298 saw_general_regs
= 1;
2299 regset
->store_function (buf
);
2303 if (saw_general_regs
)
2310 regsets_store_inferior_registers ()
2312 struct regset_info
*regset
;
2313 int saw_general_regs
= 0;
2316 regset
= target_regsets
;
2318 pid
= lwpid_of (get_thread_lwp (current_inferior
));
2319 while (regset
->size
>= 0)
2324 if (regset
->size
== 0 || disabled_regsets
[regset
- target_regsets
])
2330 buf
= xmalloc (regset
->size
);
2332 /* First fill the buffer with the current register set contents,
2333 in case there are any items in the kernel's regset that are
2334 not in gdbserver's regcache. */
2336 res
= ptrace (regset
->get_request
, pid
, 0, buf
);
2338 res
= ptrace (regset
->get_request
, pid
, buf
, 0);
2343 /* Then overlay our cached registers on that. */
2344 regset
->fill_function (buf
);
2346 /* Only now do we write the register set. */
2348 res
= ptrace (regset
->set_request
, pid
, 0, buf
);
2350 res
= ptrace (regset
->set_request
, pid
, buf
, 0);
2358 /* If we get EIO on a regset, do not try it again for
2360 disabled_regsets
[regset
- target_regsets
] = 1;
2364 else if (errno
== ESRCH
)
2366 /* At this point, ESRCH should mean the process is
2367 already gone, in which case we simply ignore attempts
2368 to change its registers. See also the related
2369 comment in linux_resume_one_lwp. */
2375 perror ("Warning: ptrace(regsets_store_inferior_registers)");
2378 else if (regset
->type
== GENERAL_REGS
)
2379 saw_general_regs
= 1;
2383 if (saw_general_regs
)
2390 #endif /* HAVE_LINUX_REGSETS */
2394 linux_fetch_registers (int regno
)
2396 #ifdef HAVE_LINUX_REGSETS
2397 if (regsets_fetch_inferior_registers () == 0)
2400 #ifdef HAVE_LINUX_USRREGS
2401 usr_fetch_inferior_registers (regno
);
2406 linux_store_registers (int regno
)
2408 #ifdef HAVE_LINUX_REGSETS
2409 if (regsets_store_inferior_registers () == 0)
2412 #ifdef HAVE_LINUX_USRREGS
2413 usr_store_inferior_registers (regno
);
2418 /* Copy LEN bytes from inferior's memory starting at MEMADDR
2419 to debugger memory starting at MYADDR. */
2422 linux_read_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
2425 /* Round starting address down to longword boundary. */
2426 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
2427 /* Round ending address up; get number of longwords that makes. */
2429 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
2430 / sizeof (PTRACE_XFER_TYPE
);
2431 /* Allocate buffer of that many longwords. */
2432 register PTRACE_XFER_TYPE
*buffer
2433 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
2436 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
2438 /* Try using /proc. Don't bother for one word. */
2439 if (len
>= 3 * sizeof (long))
2441 /* We could keep this file open and cache it - possibly one per
2442 thread. That requires some juggling, but is even faster. */
2443 sprintf (filename
, "/proc/%d/mem", pid
);
2444 fd
= open (filename
, O_RDONLY
| O_LARGEFILE
);
2448 /* If pread64 is available, use it. It's faster if the kernel
2449 supports it (only one syscall), and it's 64-bit safe even on
2450 32-bit platforms (for instance, SPARC debugging a SPARC64
2453 if (pread64 (fd
, myaddr
, len
, memaddr
) != len
)
2455 if (lseek (fd
, memaddr
, SEEK_SET
) == -1 || read (fd
, myaddr
, len
) != len
)
2467 /* Read all the longwords */
2468 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
2471 buffer
[i
] = ptrace (PTRACE_PEEKTEXT
, pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
2476 /* Copy appropriate bytes out of the buffer. */
2478 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
2484 /* Copy LEN bytes of data from debugger memory at MYADDR
2485 to inferior's memory at MEMADDR.
2486 On failure (cannot write the inferior)
2487 returns the value of errno. */
2490 linux_write_memory (CORE_ADDR memaddr
, const unsigned char *myaddr
, int len
)
2493 /* Round starting address down to longword boundary. */
2494 register CORE_ADDR addr
= memaddr
& -(CORE_ADDR
) sizeof (PTRACE_XFER_TYPE
);
2495 /* Round ending address up; get number of longwords that makes. */
2497 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1) / sizeof (PTRACE_XFER_TYPE
);
2498 /* Allocate buffer of that many longwords. */
2499 register PTRACE_XFER_TYPE
*buffer
= (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
2500 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
2504 /* Dump up to four bytes. */
2505 unsigned int val
= * (unsigned int *) myaddr
;
2511 val
= val
& 0xffffff;
2512 fprintf (stderr
, "Writing %0*x to 0x%08lx\n", 2 * ((len
< 4) ? len
: 4),
2513 val
, (long)memaddr
);
2516 /* Fill start and end extra bytes of buffer with existing memory data. */
2518 buffer
[0] = ptrace (PTRACE_PEEKTEXT
, pid
, (PTRACE_ARG3_TYPE
) addr
, 0);
2523 = ptrace (PTRACE_PEEKTEXT
, pid
,
2524 (PTRACE_ARG3_TYPE
) (addr
+ (count
- 1)
2525 * sizeof (PTRACE_XFER_TYPE
)),
2529 /* Copy data to be written over corresponding part of buffer */
2531 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)), myaddr
, len
);
2533 /* Write the entire buffer. */
2535 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
2538 ptrace (PTRACE_POKETEXT
, pid
, (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
2546 static int linux_supports_tracefork_flag
;
2548 /* Helper functions for linux_test_for_tracefork, called via clone (). */
2551 linux_tracefork_grandchild (void *arg
)
2556 #define STACK_SIZE 4096
2559 linux_tracefork_child (void *arg
)
2561 ptrace (PTRACE_TRACEME
, 0, 0, 0);
2562 kill (getpid (), SIGSTOP
);
2564 __clone2 (linux_tracefork_grandchild
, arg
, STACK_SIZE
,
2565 CLONE_VM
| SIGCHLD
, NULL
);
2567 clone (linux_tracefork_grandchild
, arg
+ STACK_SIZE
,
2568 CLONE_VM
| SIGCHLD
, NULL
);
2573 /* Determine if PTRACE_O_TRACEFORK can be used to follow fork events. Make
2574 sure that we can enable the option, and that it had the desired
2578 linux_test_for_tracefork (void)
2580 int child_pid
, ret
, status
;
2582 char *stack
= xmalloc (STACK_SIZE
* 4);
2584 linux_supports_tracefork_flag
= 0;
2586 /* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
2588 child_pid
= __clone2 (linux_tracefork_child
, stack
, STACK_SIZE
,
2589 CLONE_VM
| SIGCHLD
, stack
+ STACK_SIZE
* 2);
2591 child_pid
= clone (linux_tracefork_child
, stack
+ STACK_SIZE
,
2592 CLONE_VM
| SIGCHLD
, stack
+ STACK_SIZE
* 2);
2594 if (child_pid
== -1)
2595 perror_with_name ("clone");
2597 ret
= my_waitpid (child_pid
, &status
, 0);
2599 perror_with_name ("waitpid");
2600 else if (ret
!= child_pid
)
2601 error ("linux_test_for_tracefork: waitpid: unexpected result %d.", ret
);
2602 if (! WIFSTOPPED (status
))
2603 error ("linux_test_for_tracefork: waitpid: unexpected status %d.", status
);
2605 ret
= ptrace (PTRACE_SETOPTIONS
, child_pid
, 0, PTRACE_O_TRACEFORK
);
2608 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
2611 warning ("linux_test_for_tracefork: failed to kill child");
2615 ret
= my_waitpid (child_pid
, &status
, 0);
2616 if (ret
!= child_pid
)
2617 warning ("linux_test_for_tracefork: failed to wait for killed child");
2618 else if (!WIFSIGNALED (status
))
2619 warning ("linux_test_for_tracefork: unexpected wait status 0x%x from "
2620 "killed child", status
);
2625 ret
= ptrace (PTRACE_CONT
, child_pid
, 0, 0);
2627 warning ("linux_test_for_tracefork: failed to resume child");
2629 ret
= my_waitpid (child_pid
, &status
, 0);
2631 if (ret
== child_pid
&& WIFSTOPPED (status
)
2632 && status
>> 16 == PTRACE_EVENT_FORK
)
2635 ret
= ptrace (PTRACE_GETEVENTMSG
, child_pid
, 0, &second_pid
);
2636 if (ret
== 0 && second_pid
!= 0)
2640 linux_supports_tracefork_flag
= 1;
2641 my_waitpid (second_pid
, &second_status
, 0);
2642 ret
= ptrace (PTRACE_KILL
, second_pid
, 0, 0);
2644 warning ("linux_test_for_tracefork: failed to kill second child");
2645 my_waitpid (second_pid
, &status
, 0);
2649 warning ("linux_test_for_tracefork: unexpected result from waitpid "
2650 "(%d, status 0x%x)", ret
, status
);
2654 ret
= ptrace (PTRACE_KILL
, child_pid
, 0, 0);
2656 warning ("linux_test_for_tracefork: failed to kill child");
2657 my_waitpid (child_pid
, &status
, 0);
2659 while (WIFSTOPPED (status
));
2666 linux_look_up_symbols (void)
2668 #ifdef USE_THREAD_DB
2669 struct process_info
*proc
= current_process ();
2671 if (proc
->private->thread_db
!= NULL
)
2674 thread_db_init (!linux_supports_tracefork_flag
);
2679 linux_request_interrupt (void)
2681 extern unsigned long signal_pid
;
2683 if (!ptid_equal (cont_thread
, null_ptid
)
2684 && !ptid_equal (cont_thread
, minus_one_ptid
))
2686 struct lwp_info
*lwp
;
2689 lwp
= get_thread_lwp (current_inferior
);
2690 lwpid
= lwpid_of (lwp
);
2691 kill_lwp (lwpid
, SIGINT
);
2694 kill_lwp (signal_pid
, SIGINT
);
2697 /* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
2698 to debugger memory starting at MYADDR. */
2701 linux_read_auxv (CORE_ADDR offset
, unsigned char *myaddr
, unsigned int len
)
2703 char filename
[PATH_MAX
];
2705 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
2707 snprintf (filename
, sizeof filename
, "/proc/%d/auxv", pid
);
2709 fd
= open (filename
, O_RDONLY
);
2713 if (offset
!= (CORE_ADDR
) 0
2714 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
2717 n
= read (fd
, myaddr
, len
);
2724 /* These breakpoint and watchpoint related wrapper functions simply
2725 pass on the function call if the target has registered a
2726 corresponding function. */
2729 linux_insert_point (char type
, CORE_ADDR addr
, int len
)
2731 if (the_low_target
.insert_point
!= NULL
)
2732 return the_low_target
.insert_point (type
, addr
, len
);
2734 /* Unsupported (see target.h). */
2739 linux_remove_point (char type
, CORE_ADDR addr
, int len
)
2741 if (the_low_target
.remove_point
!= NULL
)
2742 return the_low_target
.remove_point (type
, addr
, len
);
2744 /* Unsupported (see target.h). */
2749 linux_stopped_by_watchpoint (void)
2751 if (the_low_target
.stopped_by_watchpoint
!= NULL
)
2752 return the_low_target
.stopped_by_watchpoint ();
2758 linux_stopped_data_address (void)
2760 if (the_low_target
.stopped_data_address
!= NULL
)
2761 return the_low_target
.stopped_data_address ();
2766 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
2767 #if defined(__mcoldfire__)
2768 /* These should really be defined in the kernel's ptrace.h header. */
2769 #define PT_TEXT_ADDR 49*4
2770 #define PT_DATA_ADDR 50*4
2771 #define PT_TEXT_END_ADDR 51*4
2774 /* Under uClinux, programs are loaded at non-zero offsets, which we need
2775 to tell gdb about. */
2778 linux_read_offsets (CORE_ADDR
*text_p
, CORE_ADDR
*data_p
)
2780 #if defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) && defined(PT_TEXT_END_ADDR)
2781 unsigned long text
, text_end
, data
;
2782 int pid
= lwpid_of (get_thread_lwp (current_inferior
));
2786 text
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_TEXT_ADDR
, 0);
2787 text_end
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_TEXT_END_ADDR
, 0);
2788 data
= ptrace (PTRACE_PEEKUSER
, pid
, (long)PT_DATA_ADDR
, 0);
2792 /* Both text and data offsets produced at compile-time (and so
2793 used by gdb) are relative to the beginning of the program,
2794 with the data segment immediately following the text segment.
2795 However, the actual runtime layout in memory may put the data
2796 somewhere else, so when we send gdb a data base-address, we
2797 use the real data base address and subtract the compile-time
2798 data base-address from it (which is just the length of the
2799 text segment). BSS immediately follows data in both
2802 *data_p
= data
- (text_end
- text
);
2812 compare_ints (const void *xa
, const void *xb
)
2814 int a
= *(const int *)xa
;
2815 int b
= *(const int *)xb
;
2821 unique (int *b
, int *e
)
2830 /* Given PID, iterates over all threads in that process.
2832 Information about each thread, in a format suitable for qXfer:osdata:thread
2833 is printed to BUFFER, if it's not NULL. BUFFER is assumed to be already
2834 initialized, and the caller is responsible for finishing and appending '\0'
2837 The list of cores that threads are running on is assigned to *CORES, if it
2838 is not NULL. If no cores are found, *CORES will be set to NULL. Caller
2839 should free *CORES. */
2842 list_threads (int pid
, struct buffer
*buffer
, char **cores
)
2846 int *core_numbers
= xmalloc (sizeof (int) * allocated
);
2850 struct stat statbuf
;
2852 sprintf (pathname
, "/proc/%d/task", pid
);
2853 if (stat (pathname
, &statbuf
) == 0 && S_ISDIR (statbuf
.st_mode
))
2855 dir
= opendir (pathname
);
2858 free (core_numbers
);
2862 while ((dp
= readdir (dir
)) != NULL
)
2864 unsigned long lwp
= strtoul (dp
->d_name
, NULL
, 10);
2868 unsigned core
= linux_core_of_thread (ptid_build (pid
, lwp
, 0));
2872 char s
[sizeof ("4294967295")];
2873 sprintf (s
, "%u", core
);
2875 if (count
== allocated
)
2878 core_numbers
= realloc (core_numbers
,
2879 sizeof (int) * allocated
);
2881 core_numbers
[count
++] = core
;
2883 buffer_xml_printf (buffer
,
2885 "<column name=\"pid\">%d</column>"
2886 "<column name=\"tid\">%s</column>"
2887 "<column name=\"core\">%s</column>"
2888 "</item>", pid
, dp
->d_name
, s
);
2893 buffer_xml_printf (buffer
,
2895 "<column name=\"pid\">%d</column>"
2896 "<column name=\"tid\">%s</column>"
2897 "</item>", pid
, dp
->d_name
);
2908 struct buffer buffer2
;
2911 qsort (core_numbers
, count
, sizeof (int), compare_ints
);
2913 /* Remove duplicates. */
2915 e
= unique (b
, core_numbers
+ count
);
2917 buffer_init (&buffer2
);
2919 for (b
= core_numbers
; b
!= e
; ++b
)
2921 char number
[sizeof ("4294967295")];
2922 sprintf (number
, "%u", *b
);
2923 buffer_xml_printf (&buffer2
, "%s%s",
2924 (b
== core_numbers
) ? "" : ",", number
);
2926 buffer_grow_str0 (&buffer2
, "");
2928 *cores
= buffer_finish (&buffer2
);
2931 free (core_numbers
);
2935 show_process (int pid
, const char *username
, struct buffer
*buffer
)
2939 char cmd
[MAXPATHLEN
+ 1];
2941 sprintf (pathname
, "/proc/%d/cmdline", pid
);
2943 if ((f
= fopen (pathname
, "r")) != NULL
)
2945 size_t len
= fread (cmd
, 1, sizeof (cmd
) - 1, f
);
2950 for (i
= 0; i
< len
; i
++)
2955 buffer_xml_printf (buffer
,
2957 "<column name=\"pid\">%d</column>"
2958 "<column name=\"user\">%s</column>"
2959 "<column name=\"command\">%s</column>",
2964 /* This only collects core numbers, and does not print threads. */
2965 list_threads (pid
, NULL
, &cores
);
2969 buffer_xml_printf (buffer
,
2970 "<column name=\"cores\">%s</column>", cores
);
2974 buffer_xml_printf (buffer
, "</item>");
2981 linux_qxfer_osdata (const char *annex
,
2982 unsigned char *readbuf
, unsigned const char *writebuf
,
2983 CORE_ADDR offset
, int len
)
2985 /* We make the process list snapshot when the object starts to be
2987 static const char *buf
;
2988 static long len_avail
= -1;
2989 static struct buffer buffer
;
2995 if (strcmp (annex
, "processes") == 0)
2997 else if (strcmp (annex
, "threads") == 0)
3002 if (!readbuf
|| writebuf
)
3007 if (len_avail
!= -1 && len_avail
!= 0)
3008 buffer_free (&buffer
);
3011 buffer_init (&buffer
);
3013 buffer_grow_str (&buffer
, "<osdata type=\"processes\">");
3015 buffer_grow_str (&buffer
, "<osdata type=\"threads\">");
3017 dirp
= opendir ("/proc");
3021 while ((dp
= readdir (dirp
)) != NULL
)
3023 struct stat statbuf
;
3024 char procentry
[sizeof ("/proc/4294967295")];
3026 if (!isdigit (dp
->d_name
[0])
3027 || strlen (dp
->d_name
) > sizeof ("4294967295") - 1)
3030 sprintf (procentry
, "/proc/%s", dp
->d_name
);
3031 if (stat (procentry
, &statbuf
) == 0
3032 && S_ISDIR (statbuf
.st_mode
))
3034 int pid
= (int) strtoul (dp
->d_name
, NULL
, 10);
3038 struct passwd
*entry
= getpwuid (statbuf
.st_uid
);
3039 show_process (pid
, entry
? entry
->pw_name
: "?", &buffer
);
3043 list_threads (pid
, &buffer
, NULL
);
3050 buffer_grow_str0 (&buffer
, "</osdata>\n");
3051 buf
= buffer_finish (&buffer
);
3052 len_avail
= strlen (buf
);
3055 if (offset
>= len_avail
)
3057 /* Done. Get rid of the data. */
3058 buffer_free (&buffer
);
3064 if (len
> len_avail
- offset
)
3065 len
= len_avail
- offset
;
3066 memcpy (readbuf
, buf
+ offset
, len
);
3071 /* Convert a native/host siginfo object, into/from the siginfo in the
3072 layout of the inferiors' architecture. */
3075 siginfo_fixup (struct siginfo
*siginfo
, void *inf_siginfo
, int direction
)
3079 if (the_low_target
.siginfo_fixup
!= NULL
)
3080 done
= the_low_target
.siginfo_fixup (siginfo
, inf_siginfo
, direction
);
3082 /* If there was no callback, or the callback didn't do anything,
3083 then just do a straight memcpy. */
3087 memcpy (siginfo
, inf_siginfo
, sizeof (struct siginfo
));
3089 memcpy (inf_siginfo
, siginfo
, sizeof (struct siginfo
));
3094 linux_xfer_siginfo (const char *annex
, unsigned char *readbuf
,
3095 unsigned const char *writebuf
, CORE_ADDR offset
, int len
)
3098 struct siginfo siginfo
;
3099 char inf_siginfo
[sizeof (struct siginfo
)];
3101 if (current_inferior
== NULL
)
3104 pid
= lwpid_of (get_thread_lwp (current_inferior
));
3107 fprintf (stderr
, "%s siginfo for lwp %d.\n",
3108 readbuf
!= NULL
? "Reading" : "Writing",
3111 if (offset
> sizeof (siginfo
))
3114 if (ptrace (PTRACE_GETSIGINFO
, pid
, 0, &siginfo
) != 0)
3117 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
3118 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
3119 inferior with a 64-bit GDBSERVER should look the same as debugging it
3120 with a 32-bit GDBSERVER, we need to convert it. */
3121 siginfo_fixup (&siginfo
, inf_siginfo
, 0);
3123 if (offset
+ len
> sizeof (siginfo
))
3124 len
= sizeof (siginfo
) - offset
;
3126 if (readbuf
!= NULL
)
3127 memcpy (readbuf
, inf_siginfo
+ offset
, len
);
3130 memcpy (inf_siginfo
+ offset
, writebuf
, len
);
3132 /* Convert back to ptrace layout before flushing it out. */
3133 siginfo_fixup (&siginfo
, inf_siginfo
, 1);
3135 if (ptrace (PTRACE_SETSIGINFO
, pid
, 0, &siginfo
) != 0)
3142 /* SIGCHLD handler that serves two purposes: In non-stop/async mode,
3143 so we notice when children change state; as the handler for the
3144 sigsuspend in my_waitpid. */
3147 sigchld_handler (int signo
)
3149 int old_errno
= errno
;
3152 /* fprintf is not async-signal-safe, so call write directly. */
3153 write (2, "sigchld_handler\n", sizeof ("sigchld_handler\n") - 1);
3155 if (target_is_async_p ())
3156 async_file_mark (); /* trigger a linux_wait */
3162 linux_supports_non_stop (void)
3168 linux_async (int enable
)
3170 int previous
= (linux_event_pipe
[0] != -1);
3172 if (previous
!= enable
)
3175 sigemptyset (&mask
);
3176 sigaddset (&mask
, SIGCHLD
);
3178 sigprocmask (SIG_BLOCK
, &mask
, NULL
);
3182 if (pipe (linux_event_pipe
) == -1)
3183 fatal ("creating event pipe failed.");
3185 fcntl (linux_event_pipe
[0], F_SETFL
, O_NONBLOCK
);
3186 fcntl (linux_event_pipe
[1], F_SETFL
, O_NONBLOCK
);
3188 /* Register the event loop handler. */
3189 add_file_handler (linux_event_pipe
[0],
3190 handle_target_event
, NULL
);
3192 /* Always trigger a linux_wait. */
3197 delete_file_handler (linux_event_pipe
[0]);
3199 close (linux_event_pipe
[0]);
3200 close (linux_event_pipe
[1]);
3201 linux_event_pipe
[0] = -1;
3202 linux_event_pipe
[1] = -1;
3205 sigprocmask (SIG_UNBLOCK
, &mask
, NULL
);
3212 linux_start_non_stop (int nonstop
)
3214 /* Register or unregister from event-loop accordingly. */
3215 linux_async (nonstop
);
3220 linux_supports_multi_process (void)
3226 /* Enumerate spufs IDs for process PID. */
3228 spu_enumerate_spu_ids (long pid
, unsigned char *buf
, CORE_ADDR offset
, int len
)
3234 struct dirent
*entry
;
3236 sprintf (path
, "/proc/%ld/fd", pid
);
3237 dir
= opendir (path
);
3242 while ((entry
= readdir (dir
)) != NULL
)
3248 fd
= atoi (entry
->d_name
);
3252 sprintf (path
, "/proc/%ld/fd/%d", pid
, fd
);
3253 if (stat (path
, &st
) != 0)
3255 if (!S_ISDIR (st
.st_mode
))
3258 if (statfs (path
, &stfs
) != 0)
3260 if (stfs
.f_type
!= SPUFS_MAGIC
)
3263 if (pos
>= offset
&& pos
+ 4 <= offset
+ len
)
3265 *(unsigned int *)(buf
+ pos
- offset
) = fd
;
3275 /* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
3276 object type, using the /proc file system. */
3278 linux_qxfer_spu (const char *annex
, unsigned char *readbuf
,
3279 unsigned const char *writebuf
,
3280 CORE_ADDR offset
, int len
)
3282 long pid
= lwpid_of (get_thread_lwp (current_inferior
));
3287 if (!writebuf
&& !readbuf
)
3295 return spu_enumerate_spu_ids (pid
, readbuf
, offset
, len
);
3298 sprintf (buf
, "/proc/%ld/fd/%s", pid
, annex
);
3299 fd
= open (buf
, writebuf
? O_WRONLY
: O_RDONLY
);
3304 && lseek (fd
, (off_t
) offset
, SEEK_SET
) != (off_t
) offset
)
3311 ret
= write (fd
, writebuf
, (size_t) len
);
3313 ret
= read (fd
, readbuf
, (size_t) len
);
3320 linux_core_of_thread (ptid_t ptid
)
3322 char filename
[sizeof ("/proc//task//stat")
3323 + 2 * 20 /* decimal digits for 2 numbers, max 2^64 bit each */
3326 char *content
= NULL
;
3329 int content_read
= 0;
3333 sprintf (filename
, "/proc/%d/task/%ld/stat",
3334 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
3335 f
= fopen (filename
, "r");
3342 content
= realloc (content
, content_read
+ 1024);
3343 n
= fread (content
+ content_read
, 1, 1024, f
);
3347 content
[content_read
] = '\0';
3352 p
= strchr (content
, '(');
3353 p
= strchr (p
, ')') + 2; /* skip ")" and a whitespace. */
3355 p
= strtok_r (p
, " ", &ts
);
3356 for (i
= 0; i
!= 36; ++i
)
3357 p
= strtok_r (NULL
, " ", &ts
);
3359 if (sscanf (p
, "%d", &core
) == 0)
3368 static struct target_ops linux_target_ops
= {
3369 linux_create_inferior
,
3377 linux_fetch_registers
,
3378 linux_store_registers
,
3381 linux_look_up_symbols
,
3382 linux_request_interrupt
,
3386 linux_stopped_by_watchpoint
,
3387 linux_stopped_data_address
,
3388 #if defined(__UCLIBC__) && defined(HAS_NOMMU)
3393 #ifdef USE_THREAD_DB
3394 thread_db_get_tls_address
,
3399 hostio_last_error_from_errno
,
3402 linux_supports_non_stop
,
3404 linux_start_non_stop
,
3405 linux_supports_multi_process
,
3406 #ifdef USE_THREAD_DB
3407 thread_db_handle_monitor_command
,
3411 linux_core_of_thread
3415 linux_init_signals ()
3417 /* FIXME drow/2002-06-09: As above, we should check with LinuxThreads
3418 to find what the cancel signal actually is. */
3419 #ifdef __SIGRTMIN /* Bionic doesn't use SIGRTMIN the way glibc does. */
3420 signal (__SIGRTMIN
+1, SIG_IGN
);
3425 initialize_low (void)
3427 struct sigaction sigchld_action
;
3428 memset (&sigchld_action
, 0, sizeof (sigchld_action
));
3429 set_target_ops (&linux_target_ops
);
3430 set_breakpoint_data (the_low_target
.breakpoint
,
3431 the_low_target
.breakpoint_len
);
3432 linux_init_signals ();
3433 linux_test_for_tracefork ();
3434 #ifdef HAVE_LINUX_REGSETS
3435 for (num_regsets
= 0; target_regsets
[num_regsets
].size
>= 0; num_regsets
++)
3437 disabled_regsets
= xmalloc (num_regsets
);
3440 sigchld_action
.sa_handler
= sigchld_handler
;
3441 sigemptyset (&sigchld_action
.sa_mask
);
3442 sigchld_action
.sa_flags
= SA_RESTART
;
3443 sigaction (SIGCHLD
, &sigchld_action
, NULL
);