]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/gdbserver/linux-low.c
Automatic date update in version.in
[thirdparty/binutils-gdb.git] / gdb / gdbserver / linux-low.c
CommitLineData
da6d8c04 1/* Low level interface to ptrace, for the remote server for GDB.
618f726f 2 Copyright (C) 1995-2016 Free Software Foundation, Inc.
da6d8c04
DJ
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
a9762ec7 8 the Free Software Foundation; either version 3 of the License, or
da6d8c04
DJ
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
a9762ec7 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
da6d8c04
DJ
18
19#include "server.h"
58caa3dc 20#include "linux-low.h"
125f8a3d 21#include "nat/linux-osdata.h"
58b4daa5 22#include "agent.h"
de0d863e 23#include "tdesc.h"
b20a6524 24#include "rsp-low.h"
da6d8c04 25
96d7229d
LM
26#include "nat/linux-nat.h"
27#include "nat/linux-waitpid.h"
8bdce1ff 28#include "gdb_wait.h"
5826e159 29#include "nat/gdb_ptrace.h"
125f8a3d
GB
30#include "nat/linux-ptrace.h"
31#include "nat/linux-procfs.h"
8cc73a39 32#include "nat/linux-personality.h"
da6d8c04
DJ
33#include <signal.h>
34#include <sys/ioctl.h>
35#include <fcntl.h>
0a30fbc4 36#include <unistd.h>
fd500816 37#include <sys/syscall.h>
f9387fc3 38#include <sched.h>
07e059b5
VP
39#include <ctype.h>
40#include <pwd.h>
41#include <sys/types.h>
42#include <dirent.h>
53ce3c39 43#include <sys/stat.h>
efcbbd14 44#include <sys/vfs.h>
1570b33e 45#include <sys/uio.h>
602e3198 46#include "filestuff.h"
c144c7a0 47#include "tracepoint.h"
533b0600 48#include "hostio.h"
276d4552 49#include <inttypes.h>
957f3f49
DE
50#ifndef ELFMAG0
51/* Don't include <linux/elf.h> here. If it got included by gdb_proc_service.h
52 then ELFMAG0 will have been defined. If it didn't get included by
53 gdb_proc_service.h then including it will likely introduce a duplicate
54 definition of elf_fpregset_t. */
55#include <elf.h>
56#endif
14d2069a 57#include "nat/linux-namespaces.h"
efcbbd14
UW
58
59#ifndef SPUFS_MAGIC
60#define SPUFS_MAGIC 0x23c9b64e
61#endif
da6d8c04 62
03583c20
UW
63#ifdef HAVE_PERSONALITY
64# include <sys/personality.h>
65# if !HAVE_DECL_ADDR_NO_RANDOMIZE
66# define ADDR_NO_RANDOMIZE 0x0040000
67# endif
68#endif
69
fd462a61
DJ
70#ifndef O_LARGEFILE
71#define O_LARGEFILE 0
72#endif
1a981360 73
db0dfaa0
LM
74/* Some targets did not define these ptrace constants from the start,
75 so gdbserver defines them locally here. In the future, these may
76 be removed after they are added to asm/ptrace.h. */
77#if !(defined(PT_TEXT_ADDR) \
78 || defined(PT_DATA_ADDR) \
79 || defined(PT_TEXT_END_ADDR))
80#if defined(__mcoldfire__)
81/* These are still undefined in 3.10 kernels. */
82#define PT_TEXT_ADDR 49*4
83#define PT_DATA_ADDR 50*4
84#define PT_TEXT_END_ADDR 51*4
85/* BFIN already defines these since at least 2.6.32 kernels. */
86#elif defined(BFIN)
87#define PT_TEXT_ADDR 220
88#define PT_TEXT_END_ADDR 224
89#define PT_DATA_ADDR 228
90/* These are still undefined in 3.10 kernels. */
91#elif defined(__TMS320C6X__)
92#define PT_TEXT_ADDR (0x10000*4)
93#define PT_DATA_ADDR (0x10004*4)
94#define PT_TEXT_END_ADDR (0x10008*4)
95#endif
96#endif
97
9accd112 98#ifdef HAVE_LINUX_BTRACE
125f8a3d 99# include "nat/linux-btrace.h"
734b0e4b 100# include "btrace-common.h"
9accd112
MM
101#endif
102
8365dcf5
TJB
103#ifndef HAVE_ELF32_AUXV_T
104/* Copied from glibc's elf.h. */
105typedef struct
106{
107 uint32_t a_type; /* Entry type */
108 union
109 {
110 uint32_t a_val; /* Integer value */
111 /* We use to have pointer elements added here. We cannot do that,
112 though, since it does not work when using 32-bit definitions
113 on 64-bit platforms and vice versa. */
114 } a_un;
115} Elf32_auxv_t;
116#endif
117
118#ifndef HAVE_ELF64_AUXV_T
119/* Copied from glibc's elf.h. */
120typedef struct
121{
122 uint64_t a_type; /* Entry type */
123 union
124 {
125 uint64_t a_val; /* Integer value */
126 /* We use to have pointer elements added here. We cannot do that,
127 though, since it does not work when using 32-bit definitions
128 on 64-bit platforms and vice versa. */
129 } a_un;
130} Elf64_auxv_t;
131#endif
132
ded48a5e
YQ
133/* Does the current host support PTRACE_GETREGSET? */
134int have_ptrace_getregset = -1;
135
cff068da
GB
136/* LWP accessors. */
137
138/* See nat/linux-nat.h. */
139
140ptid_t
141ptid_of_lwp (struct lwp_info *lwp)
142{
143 return ptid_of (get_lwp_thread (lwp));
144}
145
146/* See nat/linux-nat.h. */
147
4b134ca1
GB
148void
149lwp_set_arch_private_info (struct lwp_info *lwp,
150 struct arch_lwp_info *info)
151{
152 lwp->arch_private = info;
153}
154
155/* See nat/linux-nat.h. */
156
157struct arch_lwp_info *
158lwp_arch_private_info (struct lwp_info *lwp)
159{
160 return lwp->arch_private;
161}
162
163/* See nat/linux-nat.h. */
164
cff068da
GB
165int
166lwp_is_stopped (struct lwp_info *lwp)
167{
168 return lwp->stopped;
169}
170
171/* See nat/linux-nat.h. */
172
173enum target_stop_reason
174lwp_stop_reason (struct lwp_info *lwp)
175{
176 return lwp->stop_reason;
177}
178
05044653
PA
179/* A list of all unknown processes which receive stop signals. Some
180 other process will presumably claim each of these as forked
181 children momentarily. */
24a09b5f 182
05044653
PA
183struct simple_pid_list
184{
185 /* The process ID. */
186 int pid;
187
188 /* The status as reported by waitpid. */
189 int status;
190
191 /* Next in chain. */
192 struct simple_pid_list *next;
193};
194struct simple_pid_list *stopped_pids;
195
196/* Trivial list manipulation functions to keep track of a list of new
197 stopped processes. */
198
199static void
200add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
201{
8d749320 202 struct simple_pid_list *new_pid = XNEW (struct simple_pid_list);
05044653
PA
203
204 new_pid->pid = pid;
205 new_pid->status = status;
206 new_pid->next = *listp;
207 *listp = new_pid;
208}
209
210static int
211pull_pid_from_list (struct simple_pid_list **listp, int pid, int *statusp)
212{
213 struct simple_pid_list **p;
214
215 for (p = listp; *p != NULL; p = &(*p)->next)
216 if ((*p)->pid == pid)
217 {
218 struct simple_pid_list *next = (*p)->next;
219
220 *statusp = (*p)->status;
221 xfree (*p);
222 *p = next;
223 return 1;
224 }
225 return 0;
226}
24a09b5f 227
bde24c0a
PA
228enum stopping_threads_kind
229 {
230 /* Not stopping threads presently. */
231 NOT_STOPPING_THREADS,
232
233 /* Stopping threads. */
234 STOPPING_THREADS,
235
236 /* Stopping and suspending threads. */
237 STOPPING_AND_SUSPENDING_THREADS
238 };
239
240/* This is set while stop_all_lwps is in effect. */
241enum stopping_threads_kind stopping_threads = NOT_STOPPING_THREADS;
0d62e5e8
DJ
242
243/* FIXME make into a target method? */
24a09b5f 244int using_threads = 1;
24a09b5f 245
fa593d66
PA
246/* True if we're presently stabilizing threads (moving them out of
247 jump pads). */
248static int stabilizing_threads;
249
2acc282a 250static void linux_resume_one_lwp (struct lwp_info *lwp,
54a0b537 251 int step, int signal, siginfo_t *info);
2bd7c093 252static void linux_resume (struct thread_resume *resume_info, size_t n);
7984d532
PA
253static void stop_all_lwps (int suspend, struct lwp_info *except);
254static void unstop_all_lwps (int unsuspend, struct lwp_info *except);
fa96cb38
PA
255static int linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
256 int *wstat, int options);
95954743 257static int linux_wait_for_event (ptid_t ptid, int *wstat, int options);
b3312d80 258static struct lwp_info *add_lwp (ptid_t ptid);
94585166 259static void linux_mourn (struct process_info *process);
c35fafde 260static int linux_stopped_by_watchpoint (void);
95954743 261static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
00db26fa 262static int lwp_is_marked_dead (struct lwp_info *lwp);
d50171e4 263static void proceed_all_lwps (void);
d50171e4 264static int finish_step_over (struct lwp_info *lwp);
d50171e4 265static int kill_lwp (unsigned long lwpid, int signo);
863d01bd
PA
266static void enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info);
267static void complete_ongoing_step_over (void);
ece66d65 268static int linux_low_ptrace_options (int attached);
d50171e4 269
582511be
PA
270/* When the event-loop is doing a step-over, this points at the thread
271 being stepped. */
272ptid_t step_over_bkpt;
273
7d00775e 274/* True if the low target can hardware single-step. */
d50171e4
PA
275
276static int
277can_hardware_single_step (void)
278{
7d00775e
AT
279 if (the_low_target.supports_hardware_single_step != NULL)
280 return the_low_target.supports_hardware_single_step ();
281 else
282 return 0;
283}
284
285/* True if the low target can software single-step. Such targets
fa5308bd 286 implement the GET_NEXT_PCS callback. */
7d00775e
AT
287
288static int
289can_software_single_step (void)
290{
fa5308bd 291 return (the_low_target.get_next_pcs != NULL);
d50171e4
PA
292}
293
294/* True if the low target supports memory breakpoints. If so, we'll
295 have a GET_PC implementation. */
296
297static int
298supports_breakpoints (void)
299{
300 return (the_low_target.get_pc != NULL);
301}
0d62e5e8 302
fa593d66
PA
303/* Returns true if this target can support fast tracepoints. This
304 does not mean that the in-process agent has been loaded in the
305 inferior. */
306
307static int
308supports_fast_tracepoints (void)
309{
310 return the_low_target.install_fast_tracepoint_jump_pad != NULL;
311}
312
c2d6af84
PA
313/* True if LWP is stopped in its stepping range. */
314
315static int
316lwp_in_step_range (struct lwp_info *lwp)
317{
318 CORE_ADDR pc = lwp->stop_pc;
319
320 return (pc >= lwp->step_range_start && pc < lwp->step_range_end);
321}
322
0d62e5e8
DJ
323struct pending_signals
324{
325 int signal;
32ca6d61 326 siginfo_t info;
0d62e5e8
DJ
327 struct pending_signals *prev;
328};
611cb4a5 329
bd99dc85
PA
330/* The read/write ends of the pipe registered as waitable file in the
331 event loop. */
332static int linux_event_pipe[2] = { -1, -1 };
333
334/* True if we're currently in async mode. */
335#define target_is_async_p() (linux_event_pipe[0] != -1)
336
02fc4de7 337static void send_sigstop (struct lwp_info *lwp);
fa96cb38 338static void wait_for_sigstop (void);
bd99dc85 339
d0722149
DE
340/* Return non-zero if HEADER is a 64-bit ELF file. */
341
342static int
214d508e 343elf_64_header_p (const Elf64_Ehdr *header, unsigned int *machine)
d0722149 344{
214d508e
L
345 if (header->e_ident[EI_MAG0] == ELFMAG0
346 && header->e_ident[EI_MAG1] == ELFMAG1
347 && header->e_ident[EI_MAG2] == ELFMAG2
348 && header->e_ident[EI_MAG3] == ELFMAG3)
349 {
350 *machine = header->e_machine;
351 return header->e_ident[EI_CLASS] == ELFCLASS64;
352
353 }
354 *machine = EM_NONE;
355 return -1;
d0722149
DE
356}
357
358/* Return non-zero if FILE is a 64-bit ELF file,
359 zero if the file is not a 64-bit ELF file,
360 and -1 if the file is not accessible or doesn't exist. */
361
be07f1a2 362static int
214d508e 363elf_64_file_p (const char *file, unsigned int *machine)
d0722149 364{
957f3f49 365 Elf64_Ehdr header;
d0722149
DE
366 int fd;
367
368 fd = open (file, O_RDONLY);
369 if (fd < 0)
370 return -1;
371
372 if (read (fd, &header, sizeof (header)) != sizeof (header))
373 {
374 close (fd);
375 return 0;
376 }
377 close (fd);
378
214d508e 379 return elf_64_header_p (&header, machine);
d0722149
DE
380}
381
be07f1a2
PA
382/* Accepts an integer PID; Returns true if the executable PID is
383 running is a 64-bit ELF file.. */
384
385int
214d508e 386linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine)
be07f1a2 387{
d8d2a3ee 388 char file[PATH_MAX];
be07f1a2
PA
389
390 sprintf (file, "/proc/%d/exe", pid);
214d508e 391 return elf_64_file_p (file, machine);
be07f1a2
PA
392}
393
bd99dc85
PA
394static void
395delete_lwp (struct lwp_info *lwp)
396{
fa96cb38
PA
397 struct thread_info *thr = get_lwp_thread (lwp);
398
399 if (debug_threads)
400 debug_printf ("deleting %ld\n", lwpid_of (thr));
401
402 remove_thread (thr);
aa5ca48f 403 free (lwp->arch_private);
bd99dc85
PA
404 free (lwp);
405}
406
95954743
PA
407/* Add a process to the common process list, and set its private
408 data. */
409
410static struct process_info *
411linux_add_process (int pid, int attached)
412{
413 struct process_info *proc;
414
95954743 415 proc = add_process (pid, attached);
8d749320 416 proc->priv = XCNEW (struct process_info_private);
95954743 417
aa5ca48f 418 if (the_low_target.new_process != NULL)
fe978cb0 419 proc->priv->arch_private = the_low_target.new_process ();
aa5ca48f 420
95954743
PA
421 return proc;
422}
423
582511be
PA
424static CORE_ADDR get_pc (struct lwp_info *lwp);
425
ece66d65 426/* Call the target arch_setup function on the current thread. */
94585166
DB
427
428static void
429linux_arch_setup (void)
430{
431 the_low_target.arch_setup ();
432}
433
434/* Call the target arch_setup function on THREAD. */
435
436static void
437linux_arch_setup_thread (struct thread_info *thread)
438{
439 struct thread_info *saved_thread;
440
441 saved_thread = current_thread;
442 current_thread = thread;
443
444 linux_arch_setup ();
445
446 current_thread = saved_thread;
447}
448
449/* Handle a GNU/Linux extended wait response. If we see a clone,
450 fork, or vfork event, we need to add the new LWP to our list
451 (and return 0 so as not to report the trap to higher layers).
452 If we see an exec event, we will modify ORIG_EVENT_LWP to point
453 to a new LWP representing the new program. */
0d62e5e8 454
de0d863e 455static int
94585166 456handle_extended_wait (struct lwp_info **orig_event_lwp, int wstat)
24a09b5f 457{
94585166 458 struct lwp_info *event_lwp = *orig_event_lwp;
89a5711c 459 int event = linux_ptrace_get_extended_event (wstat);
de0d863e 460 struct thread_info *event_thr = get_lwp_thread (event_lwp);
54a0b537 461 struct lwp_info *new_lwp;
24a09b5f 462
65706a29
PA
463 gdb_assert (event_lwp->waitstatus.kind == TARGET_WAITKIND_IGNORE);
464
82075af2
JS
465 /* All extended events we currently use are mid-syscall. Only
466 PTRACE_EVENT_STOP is delivered more like a signal-stop, but
467 you have to be using PTRACE_SEIZE to get that. */
468 event_lwp->syscall_state = TARGET_WAITKIND_SYSCALL_ENTRY;
469
c269dbdb
DB
470 if ((event == PTRACE_EVENT_FORK) || (event == PTRACE_EVENT_VFORK)
471 || (event == PTRACE_EVENT_CLONE))
24a09b5f 472 {
95954743 473 ptid_t ptid;
24a09b5f 474 unsigned long new_pid;
05044653 475 int ret, status;
24a09b5f 476
de0d863e 477 /* Get the pid of the new lwp. */
d86d4aaf 478 ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_thr), (PTRACE_TYPE_ARG3) 0,
56f7af9c 479 &new_pid);
24a09b5f
DJ
480
481 /* If we haven't already seen the new PID stop, wait for it now. */
05044653 482 if (!pull_pid_from_list (&stopped_pids, new_pid, &status))
24a09b5f
DJ
483 {
484 /* The new child has a pending SIGSTOP. We can't affect it until it
485 hits the SIGSTOP, but we're already attached. */
486
97438e3f 487 ret = my_waitpid (new_pid, &status, __WALL);
24a09b5f
DJ
488
489 if (ret == -1)
490 perror_with_name ("waiting for new child");
491 else if (ret != new_pid)
492 warning ("wait returned unexpected PID %d", ret);
da5898ce 493 else if (!WIFSTOPPED (status))
24a09b5f
DJ
494 warning ("wait returned unexpected status 0x%x", status);
495 }
496
c269dbdb 497 if (event == PTRACE_EVENT_FORK || event == PTRACE_EVENT_VFORK)
de0d863e
DB
498 {
499 struct process_info *parent_proc;
500 struct process_info *child_proc;
501 struct lwp_info *child_lwp;
bfacd19d 502 struct thread_info *child_thr;
de0d863e
DB
503 struct target_desc *tdesc;
504
505 ptid = ptid_build (new_pid, new_pid, 0);
506
507 if (debug_threads)
508 {
509 debug_printf ("HEW: Got fork event from LWP %ld, "
510 "new child is %d\n",
511 ptid_get_lwp (ptid_of (event_thr)),
512 ptid_get_pid (ptid));
513 }
514
515 /* Add the new process to the tables and clone the breakpoint
516 lists of the parent. We need to do this even if the new process
517 will be detached, since we will need the process object and the
518 breakpoints to remove any breakpoints from memory when we
519 detach, and the client side will access registers. */
520 child_proc = linux_add_process (new_pid, 0);
521 gdb_assert (child_proc != NULL);
522 child_lwp = add_lwp (ptid);
523 gdb_assert (child_lwp != NULL);
524 child_lwp->stopped = 1;
bfacd19d
DB
525 child_lwp->must_set_ptrace_flags = 1;
526 child_lwp->status_pending_p = 0;
527 child_thr = get_lwp_thread (child_lwp);
528 child_thr->last_resume_kind = resume_stop;
998d452a
PA
529 child_thr->last_status.kind = TARGET_WAITKIND_STOPPED;
530
863d01bd 531 /* If we're suspending all threads, leave this one suspended
0f8288ae
YQ
532 too. If the fork/clone parent is stepping over a breakpoint,
533 all other threads have been suspended already. Leave the
534 child suspended too. */
535 if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS
536 || event_lwp->bp_reinsert != 0)
863d01bd
PA
537 {
538 if (debug_threads)
539 debug_printf ("HEW: leaving child suspended\n");
540 child_lwp->suspended = 1;
541 }
542
de0d863e
DB
543 parent_proc = get_thread_process (event_thr);
544 child_proc->attached = parent_proc->attached;
545 clone_all_breakpoints (&child_proc->breakpoints,
546 &child_proc->raw_breakpoints,
547 parent_proc->breakpoints);
548
8d749320 549 tdesc = XNEW (struct target_desc);
de0d863e
DB
550 copy_target_description (tdesc, parent_proc->tdesc);
551 child_proc->tdesc = tdesc;
de0d863e 552
3a8a0396
DB
553 /* Clone arch-specific process data. */
554 if (the_low_target.new_fork != NULL)
555 the_low_target.new_fork (parent_proc, child_proc);
556
de0d863e 557 /* Save fork info in the parent thread. */
c269dbdb
DB
558 if (event == PTRACE_EVENT_FORK)
559 event_lwp->waitstatus.kind = TARGET_WAITKIND_FORKED;
560 else if (event == PTRACE_EVENT_VFORK)
561 event_lwp->waitstatus.kind = TARGET_WAITKIND_VFORKED;
562
de0d863e 563 event_lwp->waitstatus.value.related_pid = ptid;
c269dbdb 564
de0d863e
DB
565 /* The status_pending field contains bits denoting the
566 extended event, so when the pending event is handled,
567 the handler will look at lwp->waitstatus. */
568 event_lwp->status_pending_p = 1;
569 event_lwp->status_pending = wstat;
570
571 /* Report the event. */
572 return 0;
573 }
574
fa96cb38
PA
575 if (debug_threads)
576 debug_printf ("HEW: Got clone event "
577 "from LWP %ld, new child is LWP %ld\n",
578 lwpid_of (event_thr), new_pid);
579
d86d4aaf 580 ptid = ptid_build (pid_of (event_thr), new_pid, 0);
b3312d80 581 new_lwp = add_lwp (ptid);
24a09b5f 582
e27d73f6
DE
583 /* Either we're going to immediately resume the new thread
584 or leave it stopped. linux_resume_one_lwp is a nop if it
585 thinks the thread is currently running, so set this first
586 before calling linux_resume_one_lwp. */
587 new_lwp->stopped = 1;
588
0f8288ae
YQ
589 /* If we're suspending all threads, leave this one suspended
590 too. If the fork/clone parent is stepping over a breakpoint,
591 all other threads have been suspended already. Leave the
592 child suspended too. */
593 if (stopping_threads == STOPPING_AND_SUSPENDING_THREADS
594 || event_lwp->bp_reinsert != 0)
bde24c0a
PA
595 new_lwp->suspended = 1;
596
da5898ce
DJ
597 /* Normally we will get the pending SIGSTOP. But in some cases
598 we might get another signal delivered to the group first.
f21cc1a2 599 If we do get another signal, be sure not to lose it. */
20ba1ce6 600 if (WSTOPSIG (status) != SIGSTOP)
da5898ce 601 {
54a0b537 602 new_lwp->stop_expected = 1;
20ba1ce6
PA
603 new_lwp->status_pending_p = 1;
604 new_lwp->status_pending = status;
da5898ce 605 }
65706a29
PA
606 else if (report_thread_events)
607 {
608 new_lwp->waitstatus.kind = TARGET_WAITKIND_THREAD_CREATED;
609 new_lwp->status_pending_p = 1;
610 new_lwp->status_pending = status;
611 }
de0d863e
DB
612
613 /* Don't report the event. */
614 return 1;
24a09b5f 615 }
c269dbdb
DB
616 else if (event == PTRACE_EVENT_VFORK_DONE)
617 {
618 event_lwp->waitstatus.kind = TARGET_WAITKIND_VFORK_DONE;
619
620 /* Report the event. */
621 return 0;
622 }
94585166
DB
623 else if (event == PTRACE_EVENT_EXEC && report_exec_events)
624 {
625 struct process_info *proc;
82075af2 626 VEC (int) *syscalls_to_catch;
94585166
DB
627 ptid_t event_ptid;
628 pid_t event_pid;
629
630 if (debug_threads)
631 {
632 debug_printf ("HEW: Got exec event from LWP %ld\n",
633 lwpid_of (event_thr));
634 }
635
636 /* Get the event ptid. */
637 event_ptid = ptid_of (event_thr);
638 event_pid = ptid_get_pid (event_ptid);
639
82075af2 640 /* Save the syscall list from the execing process. */
94585166 641 proc = get_thread_process (event_thr);
82075af2
JS
642 syscalls_to_catch = proc->syscalls_to_catch;
643 proc->syscalls_to_catch = NULL;
644
645 /* Delete the execing process and all its threads. */
94585166
DB
646 linux_mourn (proc);
647 current_thread = NULL;
648
649 /* Create a new process/lwp/thread. */
650 proc = linux_add_process (event_pid, 0);
651 event_lwp = add_lwp (event_ptid);
652 event_thr = get_lwp_thread (event_lwp);
653 gdb_assert (current_thread == event_thr);
654 linux_arch_setup_thread (event_thr);
655
656 /* Set the event status. */
657 event_lwp->waitstatus.kind = TARGET_WAITKIND_EXECD;
658 event_lwp->waitstatus.value.execd_pathname
659 = xstrdup (linux_proc_pid_to_exec_file (lwpid_of (event_thr)));
660
661 /* Mark the exec status as pending. */
662 event_lwp->stopped = 1;
663 event_lwp->status_pending_p = 1;
664 event_lwp->status_pending = wstat;
665 event_thr->last_resume_kind = resume_continue;
666 event_thr->last_status.kind = TARGET_WAITKIND_IGNORE;
667
82075af2
JS
668 /* Update syscall state in the new lwp, effectively mid-syscall too. */
669 event_lwp->syscall_state = TARGET_WAITKIND_SYSCALL_ENTRY;
670
671 /* Restore the list to catch. Don't rely on the client, which is free
672 to avoid sending a new list when the architecture doesn't change.
673 Also, for ANY_SYSCALL, the architecture doesn't really matter. */
674 proc->syscalls_to_catch = syscalls_to_catch;
675
94585166
DB
676 /* Report the event. */
677 *orig_event_lwp = event_lwp;
678 return 0;
679 }
de0d863e
DB
680
681 internal_error (__FILE__, __LINE__, _("unknown ptrace event %d"), event);
24a09b5f
DJ
682}
683
d50171e4
PA
684/* Return the PC as read from the regcache of LWP, without any
685 adjustment. */
686
687static CORE_ADDR
688get_pc (struct lwp_info *lwp)
689{
0bfdf32f 690 struct thread_info *saved_thread;
d50171e4
PA
691 struct regcache *regcache;
692 CORE_ADDR pc;
693
694 if (the_low_target.get_pc == NULL)
695 return 0;
696
0bfdf32f
GB
697 saved_thread = current_thread;
698 current_thread = get_lwp_thread (lwp);
d50171e4 699
0bfdf32f 700 regcache = get_thread_regcache (current_thread, 1);
d50171e4
PA
701 pc = (*the_low_target.get_pc) (regcache);
702
703 if (debug_threads)
87ce2a04 704 debug_printf ("pc is 0x%lx\n", (long) pc);
d50171e4 705
0bfdf32f 706 current_thread = saved_thread;
d50171e4
PA
707 return pc;
708}
709
82075af2
JS
710/* This function should only be called if LWP got a SYSCALL_SIGTRAP.
711 Fill *SYSNO with the syscall nr trapped. Fill *SYSRET with the
712 return code. */
713
714static void
715get_syscall_trapinfo (struct lwp_info *lwp, int *sysno, int *sysret)
716{
717 struct thread_info *saved_thread;
718 struct regcache *regcache;
719
720 if (the_low_target.get_syscall_trapinfo == NULL)
721 {
722 /* If we cannot get the syscall trapinfo, report an unknown
723 system call number and -ENOSYS return value. */
724 *sysno = UNKNOWN_SYSCALL;
725 *sysret = -ENOSYS;
726 return;
727 }
728
729 saved_thread = current_thread;
730 current_thread = get_lwp_thread (lwp);
731
732 regcache = get_thread_regcache (current_thread, 1);
733 (*the_low_target.get_syscall_trapinfo) (regcache, sysno, sysret);
734
735 if (debug_threads)
736 {
737 debug_printf ("get_syscall_trapinfo sysno %d sysret %d\n",
738 *sysno, *sysret);
739 }
740
741 current_thread = saved_thread;
742}
743
e7ad2f14 744static int check_stopped_by_watchpoint (struct lwp_info *child);
0d62e5e8 745
e7ad2f14
PA
746/* Called when the LWP stopped for a signal/trap. If it stopped for a
747 trap check what caused it (breakpoint, watchpoint, trace, etc.),
748 and save the result in the LWP's stop_reason field. If it stopped
749 for a breakpoint, decrement the PC if necessary on the lwp's
750 architecture. Returns true if we now have the LWP's stop PC. */
0d62e5e8 751
582511be 752static int
e7ad2f14 753save_stop_reason (struct lwp_info *lwp)
0d62e5e8 754{
582511be
PA
755 CORE_ADDR pc;
756 CORE_ADDR sw_breakpoint_pc;
757 struct thread_info *saved_thread;
3e572f71
PA
758#if USE_SIGTRAP_SIGINFO
759 siginfo_t siginfo;
760#endif
d50171e4
PA
761
762 if (the_low_target.get_pc == NULL)
763 return 0;
0d62e5e8 764
582511be
PA
765 pc = get_pc (lwp);
766 sw_breakpoint_pc = pc - the_low_target.decr_pc_after_break;
d50171e4 767
582511be
PA
768 /* breakpoint_at reads from the current thread. */
769 saved_thread = current_thread;
770 current_thread = get_lwp_thread (lwp);
47c0c975 771
3e572f71
PA
772#if USE_SIGTRAP_SIGINFO
773 if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
774 (PTRACE_TYPE_ARG3) 0, &siginfo) == 0)
775 {
776 if (siginfo.si_signo == SIGTRAP)
777 {
e7ad2f14
PA
778 if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code)
779 && GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
3e572f71 780 {
e7ad2f14
PA
781 /* The si_code is ambiguous on this arch -- check debug
782 registers. */
783 if (!check_stopped_by_watchpoint (lwp))
784 lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
785 }
786 else if (GDB_ARCH_IS_TRAP_BRKPT (siginfo.si_code))
787 {
788 /* If we determine the LWP stopped for a SW breakpoint,
789 trust it. Particularly don't check watchpoint
790 registers, because at least on s390, we'd find
791 stopped-by-watchpoint as long as there's a watchpoint
792 set. */
3e572f71 793 lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
3e572f71 794 }
e7ad2f14 795 else if (GDB_ARCH_IS_TRAP_HWBKPT (siginfo.si_code))
3e572f71 796 {
e7ad2f14
PA
797 /* This can indicate either a hardware breakpoint or
798 hardware watchpoint. Check debug registers. */
799 if (!check_stopped_by_watchpoint (lwp))
800 lwp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
3e572f71 801 }
2bf6fb9d
PA
802 else if (siginfo.si_code == TRAP_TRACE)
803 {
e7ad2f14
PA
804 /* We may have single stepped an instruction that
805 triggered a watchpoint. In that case, on some
806 architectures (such as x86), instead of TRAP_HWBKPT,
807 si_code indicates TRAP_TRACE, and we need to check
808 the debug registers separately. */
809 if (!check_stopped_by_watchpoint (lwp))
810 lwp->stop_reason = TARGET_STOPPED_BY_SINGLE_STEP;
2bf6fb9d 811 }
3e572f71
PA
812 }
813 }
814#else
582511be
PA
815 /* We may have just stepped a breakpoint instruction. E.g., in
816 non-stop mode, GDB first tells the thread A to step a range, and
817 then the user inserts a breakpoint inside the range. In that
8090aef2
PA
818 case we need to report the breakpoint PC. */
819 if ((!lwp->stepping || lwp->stop_pc == sw_breakpoint_pc)
582511be 820 && (*the_low_target.breakpoint_at) (sw_breakpoint_pc))
e7ad2f14
PA
821 lwp->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
822
823 if (hardware_breakpoint_inserted_here (pc))
824 lwp->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
825
826 if (lwp->stop_reason == TARGET_STOPPED_BY_NO_REASON)
827 check_stopped_by_watchpoint (lwp);
828#endif
829
830 if (lwp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT)
582511be
PA
831 {
832 if (debug_threads)
833 {
834 struct thread_info *thr = get_lwp_thread (lwp);
835
836 debug_printf ("CSBB: %s stopped by software breakpoint\n",
837 target_pid_to_str (ptid_of (thr)));
838 }
839
840 /* Back up the PC if necessary. */
841 if (pc != sw_breakpoint_pc)
e7ad2f14 842 {
582511be
PA
843 struct regcache *regcache
844 = get_thread_regcache (current_thread, 1);
845 (*the_low_target.set_pc) (regcache, sw_breakpoint_pc);
846 }
847
e7ad2f14
PA
848 /* Update this so we record the correct stop PC below. */
849 pc = sw_breakpoint_pc;
582511be 850 }
e7ad2f14 851 else if (lwp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT)
582511be
PA
852 {
853 if (debug_threads)
854 {
855 struct thread_info *thr = get_lwp_thread (lwp);
856
857 debug_printf ("CSBB: %s stopped by hardware breakpoint\n",
858 target_pid_to_str (ptid_of (thr)));
859 }
e7ad2f14
PA
860 }
861 else if (lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
862 {
863 if (debug_threads)
864 {
865 struct thread_info *thr = get_lwp_thread (lwp);
47c0c975 866
e7ad2f14
PA
867 debug_printf ("CSBB: %s stopped by hardware watchpoint\n",
868 target_pid_to_str (ptid_of (thr)));
869 }
582511be 870 }
e7ad2f14
PA
871 else if (lwp->stop_reason == TARGET_STOPPED_BY_SINGLE_STEP)
872 {
873 if (debug_threads)
874 {
875 struct thread_info *thr = get_lwp_thread (lwp);
582511be 876
e7ad2f14
PA
877 debug_printf ("CSBB: %s stopped by trace\n",
878 target_pid_to_str (ptid_of (thr)));
879 }
880 }
881
882 lwp->stop_pc = pc;
582511be 883 current_thread = saved_thread;
e7ad2f14 884 return 1;
0d62e5e8 885}
ce3a066d 886
b3312d80 887static struct lwp_info *
95954743 888add_lwp (ptid_t ptid)
611cb4a5 889{
54a0b537 890 struct lwp_info *lwp;
0d62e5e8 891
8d749320 892 lwp = XCNEW (struct lwp_info);
00db26fa
PA
893
894 lwp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
0d62e5e8 895
aa5ca48f 896 if (the_low_target.new_thread != NULL)
34c703da 897 the_low_target.new_thread (lwp);
aa5ca48f 898
f7667f0d 899 lwp->thread = add_thread (ptid, lwp);
0d62e5e8 900
54a0b537 901 return lwp;
0d62e5e8 902}
611cb4a5 903
da6d8c04
DJ
904/* Start an inferior process and returns its pid.
905 ALLARGS is a vector of program-name and args. */
906
ce3a066d
DJ
907static int
908linux_create_inferior (char *program, char **allargs)
da6d8c04 909{
a6dbe5df 910 struct lwp_info *new_lwp;
da6d8c04 911 int pid;
95954743 912 ptid_t ptid;
8cc73a39
SDJ
913 struct cleanup *restore_personality
914 = maybe_disable_address_space_randomization (disable_randomization);
03583c20 915
42c81e2a 916#if defined(__UCLIBC__) && defined(HAS_NOMMU)
52fb6437
NS
917 pid = vfork ();
918#else
da6d8c04 919 pid = fork ();
52fb6437 920#endif
da6d8c04
DJ
921 if (pid < 0)
922 perror_with_name ("fork");
923
924 if (pid == 0)
925 {
602e3198 926 close_most_fds ();
b8e1b30e 927 ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
da6d8c04 928
a9fa9f7d
DJ
929 setpgid (0, 0);
930
e0f9f062
DE
931 /* If gdbserver is connected to gdb via stdio, redirect the inferior's
932 stdout to stderr so that inferior i/o doesn't corrupt the connection.
933 Also, redirect stdin to /dev/null. */
934 if (remote_connection_is_stdio ())
935 {
936 close (0);
937 open ("/dev/null", O_RDONLY);
938 dup2 (2, 1);
3e52c33d
JK
939 if (write (2, "stdin/stdout redirected\n",
940 sizeof ("stdin/stdout redirected\n") - 1) < 0)
8c29b58e
YQ
941 {
942 /* Errors ignored. */;
943 }
e0f9f062
DE
944 }
945
2b876972
DJ
946 execv (program, allargs);
947 if (errno == ENOENT)
948 execvp (program, allargs);
da6d8c04
DJ
949
950 fprintf (stderr, "Cannot exec %s: %s.\n", program,
d07c63e7 951 strerror (errno));
da6d8c04
DJ
952 fflush (stderr);
953 _exit (0177);
954 }
955
8cc73a39 956 do_cleanups (restore_personality);
03583c20 957
55d7b841 958 linux_add_process (pid, 0);
95954743
PA
959
960 ptid = ptid_build (pid, pid, 0);
961 new_lwp = add_lwp (ptid);
a6dbe5df 962 new_lwp->must_set_ptrace_flags = 1;
611cb4a5 963
a9fa9f7d 964 return pid;
da6d8c04
DJ
965}
966
ece66d65
JS
967/* Implement the post_create_inferior target_ops method. */
968
969static void
970linux_post_create_inferior (void)
971{
972 struct lwp_info *lwp = get_thread_lwp (current_thread);
973
974 linux_arch_setup ();
975
976 if (lwp->must_set_ptrace_flags)
977 {
978 struct process_info *proc = current_process ();
979 int options = linux_low_ptrace_options (proc->attached);
980
981 linux_enable_event_reporting (lwpid_of (current_thread), options);
982 lwp->must_set_ptrace_flags = 0;
983 }
984}
985
8784d563
PA
986/* Attach to an inferior process. Returns 0 on success, ERRNO on
987 error. */
da6d8c04 988
7ae1a6a6
PA
989int
990linux_attach_lwp (ptid_t ptid)
da6d8c04 991{
54a0b537 992 struct lwp_info *new_lwp;
7ae1a6a6 993 int lwpid = ptid_get_lwp (ptid);
611cb4a5 994
b8e1b30e 995 if (ptrace (PTRACE_ATTACH, lwpid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0)
56f7af9c 996 != 0)
7ae1a6a6 997 return errno;
24a09b5f 998
b3312d80 999 new_lwp = add_lwp (ptid);
0d62e5e8 1000
a6dbe5df
PA
1001 /* We need to wait for SIGSTOP before being able to make the next
1002 ptrace call on this LWP. */
1003 new_lwp->must_set_ptrace_flags = 1;
1004
644cebc9 1005 if (linux_proc_pid_is_stopped (lwpid))
c14d7ab2
PA
1006 {
1007 if (debug_threads)
87ce2a04 1008 debug_printf ("Attached to a stopped process\n");
c14d7ab2
PA
1009
1010 /* The process is definitely stopped. It is in a job control
1011 stop, unless the kernel predates the TASK_STOPPED /
1012 TASK_TRACED distinction, in which case it might be in a
1013 ptrace stop. Make sure it is in a ptrace stop; from there we
1014 can kill it, signal it, et cetera.
1015
1016 First make sure there is a pending SIGSTOP. Since we are
1017 already attached, the process can not transition from stopped
1018 to running without a PTRACE_CONT; so we know this signal will
1019 go into the queue. The SIGSTOP generated by PTRACE_ATTACH is
1020 probably already in the queue (unless this kernel is old
1021 enough to use TASK_STOPPED for ptrace stops); but since
1022 SIGSTOP is not an RT signal, it can only be queued once. */
1023 kill_lwp (lwpid, SIGSTOP);
1024
1025 /* Finally, resume the stopped process. This will deliver the
1026 SIGSTOP (or a higher priority signal, just like normal
1027 PTRACE_ATTACH), which we'll catch later on. */
b8e1b30e 1028 ptrace (PTRACE_CONT, lwpid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
c14d7ab2
PA
1029 }
1030
0d62e5e8 1031 /* The next time we wait for this LWP we'll see a SIGSTOP as PTRACE_ATTACH
0e21c1ec
DE
1032 brings it to a halt.
1033
1034 There are several cases to consider here:
1035
1036 1) gdbserver has already attached to the process and is being notified
1b3f6016 1037 of a new thread that is being created.
d50171e4
PA
1038 In this case we should ignore that SIGSTOP and resume the
1039 process. This is handled below by setting stop_expected = 1,
8336d594 1040 and the fact that add_thread sets last_resume_kind ==
d50171e4 1041 resume_continue.
0e21c1ec
DE
1042
1043 2) This is the first thread (the process thread), and we're attaching
1b3f6016
PA
1044 to it via attach_inferior.
1045 In this case we want the process thread to stop.
d50171e4
PA
1046 This is handled by having linux_attach set last_resume_kind ==
1047 resume_stop after we return.
e3deef73
LM
1048
1049 If the pid we are attaching to is also the tgid, we attach to and
1050 stop all the existing threads. Otherwise, we attach to pid and
1051 ignore any other threads in the same group as this pid.
0e21c1ec
DE
1052
1053 3) GDB is connecting to gdbserver and is requesting an enumeration of all
1b3f6016
PA
1054 existing threads.
1055 In this case we want the thread to stop.
1056 FIXME: This case is currently not properly handled.
1057 We should wait for the SIGSTOP but don't. Things work apparently
1058 because enough time passes between when we ptrace (ATTACH) and when
1059 gdb makes the next ptrace call on the thread.
0d62e5e8
DJ
1060
1061 On the other hand, if we are currently trying to stop all threads, we
1062 should treat the new thread as if we had sent it a SIGSTOP. This works
54a0b537 1063 because we are guaranteed that the add_lwp call above added us to the
0e21c1ec
DE
1064 end of the list, and so the new thread has not yet reached
1065 wait_for_sigstop (but will). */
d50171e4 1066 new_lwp->stop_expected = 1;
0d62e5e8 1067
7ae1a6a6 1068 return 0;
95954743
PA
1069}
1070
8784d563
PA
1071/* Callback for linux_proc_attach_tgid_threads. Attach to PTID if not
1072 already attached. Returns true if a new LWP is found, false
1073 otherwise. */
1074
1075static int
1076attach_proc_task_lwp_callback (ptid_t ptid)
1077{
1078 /* Is this a new thread? */
1079 if (find_thread_ptid (ptid) == NULL)
1080 {
1081 int lwpid = ptid_get_lwp (ptid);
1082 int err;
1083
1084 if (debug_threads)
1085 debug_printf ("Found new lwp %d\n", lwpid);
1086
1087 err = linux_attach_lwp (ptid);
1088
1089 /* Be quiet if we simply raced with the thread exiting. EPERM
1090 is returned if the thread's task still exists, and is marked
1091 as exited or zombie, as well as other conditions, so in that
1092 case, confirm the status in /proc/PID/status. */
1093 if (err == ESRCH
1094 || (err == EPERM && linux_proc_pid_is_gone (lwpid)))
1095 {
1096 if (debug_threads)
1097 {
1098 debug_printf ("Cannot attach to lwp %d: "
1099 "thread is gone (%d: %s)\n",
1100 lwpid, err, strerror (err));
1101 }
1102 }
1103 else if (err != 0)
1104 {
1105 warning (_("Cannot attach to lwp %d: %s"),
1106 lwpid,
1107 linux_ptrace_attach_fail_reason_string (ptid, err));
1108 }
1109
1110 return 1;
1111 }
1112 return 0;
1113}
1114
500c1d85
PA
1115static void async_file_mark (void);
1116
e3deef73
LM
1117/* Attach to PID. If PID is the tgid, attach to it and all
1118 of its threads. */
1119
c52daf70 1120static int
a1928bad 1121linux_attach (unsigned long pid)
0d62e5e8 1122{
500c1d85
PA
1123 struct process_info *proc;
1124 struct thread_info *initial_thread;
7ae1a6a6
PA
1125 ptid_t ptid = ptid_build (pid, pid, 0);
1126 int err;
1127
e3deef73
LM
1128 /* Attach to PID. We will check for other threads
1129 soon. */
7ae1a6a6
PA
1130 err = linux_attach_lwp (ptid);
1131 if (err != 0)
1132 error ("Cannot attach to process %ld: %s",
8784d563 1133 pid, linux_ptrace_attach_fail_reason_string (ptid, err));
7ae1a6a6 1134
500c1d85 1135 proc = linux_add_process (pid, 1);
0d62e5e8 1136
500c1d85
PA
1137 /* Don't ignore the initial SIGSTOP if we just attached to this
1138 process. It will be collected by wait shortly. */
1139 initial_thread = find_thread_ptid (ptid_build (pid, pid, 0));
1140 initial_thread->last_resume_kind = resume_stop;
0d62e5e8 1141
8784d563
PA
1142 /* We must attach to every LWP. If /proc is mounted, use that to
1143 find them now. On the one hand, the inferior may be using raw
1144 clone instead of using pthreads. On the other hand, even if it
1145 is using pthreads, GDB may not be connected yet (thread_db needs
1146 to do symbol lookups, through qSymbol). Also, thread_db walks
1147 structures in the inferior's address space to find the list of
1148 threads/LWPs, and those structures may well be corrupted. Note
1149 that once thread_db is loaded, we'll still use it to list threads
1150 and associate pthread info with each LWP. */
1151 linux_proc_attach_tgid_threads (pid, attach_proc_task_lwp_callback);
500c1d85
PA
1152
1153 /* GDB will shortly read the xml target description for this
1154 process, to figure out the process' architecture. But the target
1155 description is only filled in when the first process/thread in
1156 the thread group reports its initial PTRACE_ATTACH SIGSTOP. Do
1157 that now, otherwise, if GDB is fast enough, it could read the
1158 target description _before_ that initial stop. */
1159 if (non_stop)
1160 {
1161 struct lwp_info *lwp;
1162 int wstat, lwpid;
1163 ptid_t pid_ptid = pid_to_ptid (pid);
1164
1165 lwpid = linux_wait_for_event_filtered (pid_ptid, pid_ptid,
1166 &wstat, __WALL);
1167 gdb_assert (lwpid > 0);
1168
1169 lwp = find_lwp_pid (pid_to_ptid (lwpid));
1170
1171 if (!WIFSTOPPED (wstat) || WSTOPSIG (wstat) != SIGSTOP)
1172 {
1173 lwp->status_pending_p = 1;
1174 lwp->status_pending = wstat;
1175 }
1176
1177 initial_thread->last_resume_kind = resume_continue;
1178
1179 async_file_mark ();
1180
1181 gdb_assert (proc->tdesc != NULL);
1182 }
1183
95954743
PA
1184 return 0;
1185}
1186
1187struct counter
1188{
1189 int pid;
1190 int count;
1191};
1192
1193static int
1194second_thread_of_pid_p (struct inferior_list_entry *entry, void *args)
1195{
9a3c8263 1196 struct counter *counter = (struct counter *) args;
95954743
PA
1197
1198 if (ptid_get_pid (entry->id) == counter->pid)
1199 {
1200 if (++counter->count > 1)
1201 return 1;
1202 }
d61ddec4 1203
da6d8c04
DJ
1204 return 0;
1205}
1206
95954743 1207static int
fa96cb38 1208last_thread_of_process_p (int pid)
95954743 1209{
95954743 1210 struct counter counter = { pid , 0 };
da6d8c04 1211
95954743
PA
1212 return (find_inferior (&all_threads,
1213 second_thread_of_pid_p, &counter) == NULL);
1214}
1215
da84f473
PA
1216/* Kill LWP. */
1217
1218static void
1219linux_kill_one_lwp (struct lwp_info *lwp)
1220{
d86d4aaf
DE
1221 struct thread_info *thr = get_lwp_thread (lwp);
1222 int pid = lwpid_of (thr);
da84f473
PA
1223
1224 /* PTRACE_KILL is unreliable. After stepping into a signal handler,
1225 there is no signal context, and ptrace(PTRACE_KILL) (or
1226 ptrace(PTRACE_CONT, SIGKILL), pretty much the same) acts like
1227 ptrace(CONT, pid, 0,0) and just resumes the tracee. A better
1228 alternative is to kill with SIGKILL. We only need one SIGKILL
1229 per process, not one for each thread. But since we still support
4a6ed09b
PA
1230 support debugging programs using raw clone without CLONE_THREAD,
1231 we send one for each thread. For years, we used PTRACE_KILL
1232 only, so we're being a bit paranoid about some old kernels where
1233 PTRACE_KILL might work better (dubious if there are any such, but
1234 that's why it's paranoia), so we try SIGKILL first, PTRACE_KILL
1235 second, and so we're fine everywhere. */
da84f473
PA
1236
1237 errno = 0;
69ff6be5 1238 kill_lwp (pid, SIGKILL);
da84f473 1239 if (debug_threads)
ce9e3fe7
PA
1240 {
1241 int save_errno = errno;
1242
1243 debug_printf ("LKL: kill_lwp (SIGKILL) %s, 0, 0 (%s)\n",
1244 target_pid_to_str (ptid_of (thr)),
1245 save_errno ? strerror (save_errno) : "OK");
1246 }
da84f473
PA
1247
1248 errno = 0;
b8e1b30e 1249 ptrace (PTRACE_KILL, pid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
da84f473 1250 if (debug_threads)
ce9e3fe7
PA
1251 {
1252 int save_errno = errno;
1253
1254 debug_printf ("LKL: PTRACE_KILL %s, 0, 0 (%s)\n",
1255 target_pid_to_str (ptid_of (thr)),
1256 save_errno ? strerror (save_errno) : "OK");
1257 }
da84f473
PA
1258}
1259
e76126e8
PA
1260/* Kill LWP and wait for it to die. */
1261
1262static void
1263kill_wait_lwp (struct lwp_info *lwp)
1264{
1265 struct thread_info *thr = get_lwp_thread (lwp);
1266 int pid = ptid_get_pid (ptid_of (thr));
1267 int lwpid = ptid_get_lwp (ptid_of (thr));
1268 int wstat;
1269 int res;
1270
1271 if (debug_threads)
1272 debug_printf ("kwl: killing lwp %d, for pid: %d\n", lwpid, pid);
1273
1274 do
1275 {
1276 linux_kill_one_lwp (lwp);
1277
1278 /* Make sure it died. Notes:
1279
1280 - The loop is most likely unnecessary.
1281
1282 - We don't use linux_wait_for_event as that could delete lwps
1283 while we're iterating over them. We're not interested in
1284 any pending status at this point, only in making sure all
1285 wait status on the kernel side are collected until the
1286 process is reaped.
1287
1288 - We don't use __WALL here as the __WALL emulation relies on
1289 SIGCHLD, and killing a stopped process doesn't generate
1290 one, nor an exit status.
1291 */
1292 res = my_waitpid (lwpid, &wstat, 0);
1293 if (res == -1 && errno == ECHILD)
1294 res = my_waitpid (lwpid, &wstat, __WCLONE);
1295 } while (res > 0 && WIFSTOPPED (wstat));
1296
586b02a9
PA
1297 /* Even if it was stopped, the child may have already disappeared.
1298 E.g., if it was killed by SIGKILL. */
1299 if (res < 0 && errno != ECHILD)
1300 perror_with_name ("kill_wait_lwp");
e76126e8
PA
1301}
1302
da84f473
PA
1303/* Callback for `find_inferior'. Kills an lwp of a given process,
1304 except the leader. */
95954743
PA
1305
1306static int
da84f473 1307kill_one_lwp_callback (struct inferior_list_entry *entry, void *args)
da6d8c04 1308{
0d62e5e8 1309 struct thread_info *thread = (struct thread_info *) entry;
54a0b537 1310 struct lwp_info *lwp = get_thread_lwp (thread);
95954743
PA
1311 int pid = * (int *) args;
1312
1313 if (ptid_get_pid (entry->id) != pid)
1314 return 0;
0d62e5e8 1315
fd500816
DJ
1316 /* We avoid killing the first thread here, because of a Linux kernel (at
1317 least 2.6.0-test7 through 2.6.8-rc4) bug; if we kill the parent before
1318 the children get a chance to be reaped, it will remain a zombie
1319 forever. */
95954743 1320
d86d4aaf 1321 if (lwpid_of (thread) == pid)
95954743
PA
1322 {
1323 if (debug_threads)
87ce2a04
DE
1324 debug_printf ("lkop: is last of process %s\n",
1325 target_pid_to_str (entry->id));
95954743
PA
1326 return 0;
1327 }
fd500816 1328
e76126e8 1329 kill_wait_lwp (lwp);
95954743 1330 return 0;
da6d8c04
DJ
1331}
1332
95954743
PA
1333static int
1334linux_kill (int pid)
0d62e5e8 1335{
95954743 1336 struct process_info *process;
54a0b537 1337 struct lwp_info *lwp;
fd500816 1338
95954743
PA
1339 process = find_process_pid (pid);
1340 if (process == NULL)
1341 return -1;
9d606399 1342
f9e39928
PA
1343 /* If we're killing a running inferior, make sure it is stopped
1344 first, as PTRACE_KILL will not work otherwise. */
7984d532 1345 stop_all_lwps (0, NULL);
f9e39928 1346
da84f473 1347 find_inferior (&all_threads, kill_one_lwp_callback , &pid);
fd500816 1348
54a0b537 1349 /* See the comment in linux_kill_one_lwp. We did not kill the first
fd500816 1350 thread in the list, so do so now. */
95954743 1351 lwp = find_lwp_pid (pid_to_ptid (pid));
bd99dc85 1352
784867a5 1353 if (lwp == NULL)
fd500816 1354 {
784867a5 1355 if (debug_threads)
d86d4aaf
DE
1356 debug_printf ("lk_1: cannot find lwp for pid: %d\n",
1357 pid);
784867a5
JK
1358 }
1359 else
e76126e8 1360 kill_wait_lwp (lwp);
2d717e4f 1361
8336d594 1362 the_target->mourn (process);
f9e39928
PA
1363
1364 /* Since we presently can only stop all lwps of all processes, we
1365 need to unstop lwps of other processes. */
7984d532 1366 unstop_all_lwps (0, NULL);
95954743 1367 return 0;
0d62e5e8
DJ
1368}
1369
9b224c5e
PA
1370/* Get pending signal of THREAD, for detaching purposes. This is the
1371 signal the thread last stopped for, which we need to deliver to the
1372 thread when detaching, otherwise, it'd be suppressed/lost. */
1373
1374static int
1375get_detach_signal (struct thread_info *thread)
1376{
a493e3e2 1377 enum gdb_signal signo = GDB_SIGNAL_0;
9b224c5e
PA
1378 int status;
1379 struct lwp_info *lp = get_thread_lwp (thread);
1380
1381 if (lp->status_pending_p)
1382 status = lp->status_pending;
1383 else
1384 {
1385 /* If the thread had been suspended by gdbserver, and it stopped
1386 cleanly, then it'll have stopped with SIGSTOP. But we don't
1387 want to deliver that SIGSTOP. */
1388 if (thread->last_status.kind != TARGET_WAITKIND_STOPPED
a493e3e2 1389 || thread->last_status.value.sig == GDB_SIGNAL_0)
9b224c5e
PA
1390 return 0;
1391
1392 /* Otherwise, we may need to deliver the signal we
1393 intercepted. */
1394 status = lp->last_status;
1395 }
1396
1397 if (!WIFSTOPPED (status))
1398 {
1399 if (debug_threads)
87ce2a04 1400 debug_printf ("GPS: lwp %s hasn't stopped: no pending signal\n",
d86d4aaf 1401 target_pid_to_str (ptid_of (thread)));
9b224c5e
PA
1402 return 0;
1403 }
1404
1405 /* Extended wait statuses aren't real SIGTRAPs. */
89a5711c 1406 if (WSTOPSIG (status) == SIGTRAP && linux_is_extended_waitstatus (status))
9b224c5e
PA
1407 {
1408 if (debug_threads)
87ce2a04
DE
1409 debug_printf ("GPS: lwp %s had stopped with extended "
1410 "status: no pending signal\n",
d86d4aaf 1411 target_pid_to_str (ptid_of (thread)));
9b224c5e
PA
1412 return 0;
1413 }
1414
2ea28649 1415 signo = gdb_signal_from_host (WSTOPSIG (status));
9b224c5e
PA
1416
1417 if (program_signals_p && !program_signals[signo])
1418 {
1419 if (debug_threads)
87ce2a04 1420 debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n",
d86d4aaf 1421 target_pid_to_str (ptid_of (thread)),
87ce2a04 1422 gdb_signal_to_string (signo));
9b224c5e
PA
1423 return 0;
1424 }
1425 else if (!program_signals_p
1426 /* If we have no way to know which signals GDB does not
1427 want to have passed to the program, assume
1428 SIGTRAP/SIGINT, which is GDB's default. */
a493e3e2 1429 && (signo == GDB_SIGNAL_TRAP || signo == GDB_SIGNAL_INT))
9b224c5e
PA
1430 {
1431 if (debug_threads)
87ce2a04
DE
1432 debug_printf ("GPS: lwp %s had signal %s, "
1433 "but we don't know if we should pass it. "
1434 "Default to not.\n",
d86d4aaf 1435 target_pid_to_str (ptid_of (thread)),
87ce2a04 1436 gdb_signal_to_string (signo));
9b224c5e
PA
1437 return 0;
1438 }
1439 else
1440 {
1441 if (debug_threads)
87ce2a04 1442 debug_printf ("GPS: lwp %s has pending signal %s: delivering it.\n",
d86d4aaf 1443 target_pid_to_str (ptid_of (thread)),
87ce2a04 1444 gdb_signal_to_string (signo));
9b224c5e
PA
1445
1446 return WSTOPSIG (status);
1447 }
1448}
1449
95954743
PA
1450static int
1451linux_detach_one_lwp (struct inferior_list_entry *entry, void *args)
6ad8ae5c
DJ
1452{
1453 struct thread_info *thread = (struct thread_info *) entry;
54a0b537 1454 struct lwp_info *lwp = get_thread_lwp (thread);
95954743 1455 int pid = * (int *) args;
9b224c5e 1456 int sig;
95954743
PA
1457
1458 if (ptid_get_pid (entry->id) != pid)
1459 return 0;
6ad8ae5c 1460
9b224c5e 1461 /* If there is a pending SIGSTOP, get rid of it. */
54a0b537 1462 if (lwp->stop_expected)
ae13219e 1463 {
9b224c5e 1464 if (debug_threads)
87ce2a04 1465 debug_printf ("Sending SIGCONT to %s\n",
d86d4aaf 1466 target_pid_to_str (ptid_of (thread)));
9b224c5e 1467
d86d4aaf 1468 kill_lwp (lwpid_of (thread), SIGCONT);
54a0b537 1469 lwp->stop_expected = 0;
ae13219e
DJ
1470 }
1471
1472 /* Flush any pending changes to the process's registers. */
d86d4aaf 1473 regcache_invalidate_thread (thread);
ae13219e 1474
9b224c5e
PA
1475 /* Pass on any pending signal for this thread. */
1476 sig = get_detach_signal (thread);
1477
ae13219e 1478 /* Finally, let it resume. */
82bfbe7e
PA
1479 if (the_low_target.prepare_to_resume != NULL)
1480 the_low_target.prepare_to_resume (lwp);
d86d4aaf 1481 if (ptrace (PTRACE_DETACH, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
b8e1b30e 1482 (PTRACE_TYPE_ARG4) (long) sig) < 0)
9b224c5e 1483 error (_("Can't detach %s: %s"),
d86d4aaf 1484 target_pid_to_str (ptid_of (thread)),
9b224c5e 1485 strerror (errno));
bd99dc85
PA
1486
1487 delete_lwp (lwp);
95954743 1488 return 0;
6ad8ae5c
DJ
1489}
1490
95954743
PA
1491static int
1492linux_detach (int pid)
1493{
1494 struct process_info *process;
1495
1496 process = find_process_pid (pid);
1497 if (process == NULL)
1498 return -1;
1499
863d01bd
PA
1500 /* As there's a step over already in progress, let it finish first,
1501 otherwise nesting a stabilize_threads operation on top gets real
1502 messy. */
1503 complete_ongoing_step_over ();
1504
f9e39928
PA
1505 /* Stop all threads before detaching. First, ptrace requires that
1506 the thread is stopped to sucessfully detach. Second, thread_db
1507 may need to uninstall thread event breakpoints from memory, which
1508 only works with a stopped process anyway. */
7984d532 1509 stop_all_lwps (0, NULL);
f9e39928 1510
ca5c370d 1511#ifdef USE_THREAD_DB
8336d594 1512 thread_db_detach (process);
ca5c370d
PA
1513#endif
1514
fa593d66
PA
1515 /* Stabilize threads (move out of jump pads). */
1516 stabilize_threads ();
1517
95954743 1518 find_inferior (&all_threads, linux_detach_one_lwp, &pid);
8336d594
PA
1519
1520 the_target->mourn (process);
f9e39928
PA
1521
1522 /* Since we presently can only stop all lwps of all processes, we
1523 need to unstop lwps of other processes. */
7984d532 1524 unstop_all_lwps (0, NULL);
f9e39928
PA
1525 return 0;
1526}
1527
1528/* Remove all LWPs that belong to process PROC from the lwp list. */
1529
1530static int
1531delete_lwp_callback (struct inferior_list_entry *entry, void *proc)
1532{
d86d4aaf
DE
1533 struct thread_info *thread = (struct thread_info *) entry;
1534 struct lwp_info *lwp = get_thread_lwp (thread);
9a3c8263 1535 struct process_info *process = (struct process_info *) proc;
f9e39928 1536
d86d4aaf 1537 if (pid_of (thread) == pid_of (process))
f9e39928
PA
1538 delete_lwp (lwp);
1539
dd6953e1 1540 return 0;
6ad8ae5c
DJ
1541}
1542
8336d594
PA
1543static void
1544linux_mourn (struct process_info *process)
1545{
1546 struct process_info_private *priv;
1547
1548#ifdef USE_THREAD_DB
1549 thread_db_mourn (process);
1550#endif
1551
d86d4aaf 1552 find_inferior (&all_threads, delete_lwp_callback, process);
f9e39928 1553
8336d594 1554 /* Freeing all private data. */
fe978cb0 1555 priv = process->priv;
8336d594
PA
1556 free (priv->arch_private);
1557 free (priv);
fe978cb0 1558 process->priv = NULL;
505106cd
PA
1559
1560 remove_process (process);
8336d594
PA
1561}
1562
444d6139 1563static void
95954743 1564linux_join (int pid)
444d6139 1565{
444d6139
PA
1566 int status, ret;
1567
1568 do {
95954743 1569 ret = my_waitpid (pid, &status, 0);
444d6139
PA
1570 if (WIFEXITED (status) || WIFSIGNALED (status))
1571 break;
1572 } while (ret != -1 || errno != ECHILD);
1573}
1574
6ad8ae5c 1575/* Return nonzero if the given thread is still alive. */
0d62e5e8 1576static int
95954743 1577linux_thread_alive (ptid_t ptid)
0d62e5e8 1578{
95954743
PA
1579 struct lwp_info *lwp = find_lwp_pid (ptid);
1580
1581 /* We assume we always know if a thread exits. If a whole process
1582 exited but we still haven't been able to report it to GDB, we'll
1583 hold on to the last lwp of the dead process. */
1584 if (lwp != NULL)
00db26fa 1585 return !lwp_is_marked_dead (lwp);
0d62e5e8
DJ
1586 else
1587 return 0;
1588}
1589
582511be
PA
1590/* Return 1 if this lwp still has an interesting status pending. If
1591 not (e.g., it had stopped for a breakpoint that is gone), return
1592 false. */
1593
1594static int
1595thread_still_has_status_pending_p (struct thread_info *thread)
1596{
1597 struct lwp_info *lp = get_thread_lwp (thread);
1598
1599 if (!lp->status_pending_p)
1600 return 0;
1601
582511be 1602 if (thread->last_resume_kind != resume_stop
15c66dd6
PA
1603 && (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
1604 || lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT))
582511be
PA
1605 {
1606 struct thread_info *saved_thread;
1607 CORE_ADDR pc;
1608 int discard = 0;
1609
1610 gdb_assert (lp->last_status != 0);
1611
1612 pc = get_pc (lp);
1613
1614 saved_thread = current_thread;
1615 current_thread = thread;
1616
1617 if (pc != lp->stop_pc)
1618 {
1619 if (debug_threads)
1620 debug_printf ("PC of %ld changed\n",
1621 lwpid_of (thread));
1622 discard = 1;
1623 }
3e572f71
PA
1624
1625#if !USE_SIGTRAP_SIGINFO
15c66dd6 1626 else if (lp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
582511be
PA
1627 && !(*the_low_target.breakpoint_at) (pc))
1628 {
1629 if (debug_threads)
1630 debug_printf ("previous SW breakpoint of %ld gone\n",
1631 lwpid_of (thread));
1632 discard = 1;
1633 }
15c66dd6 1634 else if (lp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT
582511be
PA
1635 && !hardware_breakpoint_inserted_here (pc))
1636 {
1637 if (debug_threads)
1638 debug_printf ("previous HW breakpoint of %ld gone\n",
1639 lwpid_of (thread));
1640 discard = 1;
1641 }
3e572f71 1642#endif
582511be
PA
1643
1644 current_thread = saved_thread;
1645
1646 if (discard)
1647 {
1648 if (debug_threads)
1649 debug_printf ("discarding pending breakpoint status\n");
1650 lp->status_pending_p = 0;
1651 return 0;
1652 }
1653 }
1654
1655 return 1;
1656}
1657
a681f9c9
PA
1658/* Returns true if LWP is resumed from the client's perspective. */
1659
1660static int
1661lwp_resumed (struct lwp_info *lwp)
1662{
1663 struct thread_info *thread = get_lwp_thread (lwp);
1664
1665 if (thread->last_resume_kind != resume_stop)
1666 return 1;
1667
1668 /* Did gdb send us a `vCont;t', but we haven't reported the
1669 corresponding stop to gdb yet? If so, the thread is still
1670 resumed/running from gdb's perspective. */
1671 if (thread->last_resume_kind == resume_stop
1672 && thread->last_status.kind == TARGET_WAITKIND_IGNORE)
1673 return 1;
1674
1675 return 0;
1676}
1677
6bf5e0ba 1678/* Return 1 if this lwp has an interesting status pending. */
611cb4a5 1679static int
d50171e4 1680status_pending_p_callback (struct inferior_list_entry *entry, void *arg)
0d62e5e8 1681{
d86d4aaf 1682 struct thread_info *thread = (struct thread_info *) entry;
582511be 1683 struct lwp_info *lp = get_thread_lwp (thread);
95954743
PA
1684 ptid_t ptid = * (ptid_t *) arg;
1685
1686 /* Check if we're only interested in events from a specific process
afa8d396
PA
1687 or a specific LWP. */
1688 if (!ptid_match (ptid_of (thread), ptid))
95954743 1689 return 0;
0d62e5e8 1690
a681f9c9
PA
1691 if (!lwp_resumed (lp))
1692 return 0;
1693
582511be
PA
1694 if (lp->status_pending_p
1695 && !thread_still_has_status_pending_p (thread))
1696 {
1697 linux_resume_one_lwp (lp, lp->stepping, GDB_SIGNAL_0, NULL);
1698 return 0;
1699 }
0d62e5e8 1700
582511be 1701 return lp->status_pending_p;
0d62e5e8
DJ
1702}
1703
95954743
PA
1704static int
1705same_lwp (struct inferior_list_entry *entry, void *data)
1706{
1707 ptid_t ptid = *(ptid_t *) data;
1708 int lwp;
1709
1710 if (ptid_get_lwp (ptid) != 0)
1711 lwp = ptid_get_lwp (ptid);
1712 else
1713 lwp = ptid_get_pid (ptid);
1714
1715 if (ptid_get_lwp (entry->id) == lwp)
1716 return 1;
1717
1718 return 0;
1719}
1720
1721struct lwp_info *
1722find_lwp_pid (ptid_t ptid)
1723{
d86d4aaf
DE
1724 struct inferior_list_entry *thread
1725 = find_inferior (&all_threads, same_lwp, &ptid);
1726
1727 if (thread == NULL)
1728 return NULL;
1729
1730 return get_thread_lwp ((struct thread_info *) thread);
95954743
PA
1731}
1732
fa96cb38 1733/* Return the number of known LWPs in the tgid given by PID. */
0d62e5e8 1734
fa96cb38
PA
1735static int
1736num_lwps (int pid)
1737{
1738 struct inferior_list_entry *inf, *tmp;
1739 int count = 0;
0d62e5e8 1740
fa96cb38 1741 ALL_INFERIORS (&all_threads, inf, tmp)
24a09b5f 1742 {
fa96cb38
PA
1743 if (ptid_get_pid (inf->id) == pid)
1744 count++;
24a09b5f 1745 }
3aee8918 1746
fa96cb38
PA
1747 return count;
1748}
d61ddec4 1749
6d4ee8c6
GB
1750/* The arguments passed to iterate_over_lwps. */
1751
1752struct iterate_over_lwps_args
1753{
1754 /* The FILTER argument passed to iterate_over_lwps. */
1755 ptid_t filter;
1756
1757 /* The CALLBACK argument passed to iterate_over_lwps. */
1758 iterate_over_lwps_ftype *callback;
1759
1760 /* The DATA argument passed to iterate_over_lwps. */
1761 void *data;
1762};
1763
1764/* Callback for find_inferior used by iterate_over_lwps to filter
1765 calls to the callback supplied to that function. Returning a
1766 nonzero value causes find_inferiors to stop iterating and return
1767 the current inferior_list_entry. Returning zero indicates that
1768 find_inferiors should continue iterating. */
1769
1770static int
1771iterate_over_lwps_filter (struct inferior_list_entry *entry, void *args_p)
1772{
1773 struct iterate_over_lwps_args *args
1774 = (struct iterate_over_lwps_args *) args_p;
1775
1776 if (ptid_match (entry->id, args->filter))
1777 {
1778 struct thread_info *thr = (struct thread_info *) entry;
1779 struct lwp_info *lwp = get_thread_lwp (thr);
1780
1781 return (*args->callback) (lwp, args->data);
1782 }
1783
1784 return 0;
1785}
1786
1787/* See nat/linux-nat.h. */
1788
1789struct lwp_info *
1790iterate_over_lwps (ptid_t filter,
1791 iterate_over_lwps_ftype callback,
1792 void *data)
1793{
1794 struct iterate_over_lwps_args args = {filter, callback, data};
1795 struct inferior_list_entry *entry;
1796
1797 entry = find_inferior (&all_threads, iterate_over_lwps_filter, &args);
1798 if (entry == NULL)
1799 return NULL;
1800
1801 return get_thread_lwp ((struct thread_info *) entry);
1802}
1803
fa96cb38
PA
1804/* Detect zombie thread group leaders, and "exit" them. We can't reap
1805 their exits until all other threads in the group have exited. */
c3adc08c 1806
fa96cb38
PA
1807static void
1808check_zombie_leaders (void)
1809{
1810 struct process_info *proc, *tmp;
c3adc08c 1811
fa96cb38 1812 ALL_PROCESSES (proc, tmp)
c3adc08c 1813 {
fa96cb38
PA
1814 pid_t leader_pid = pid_of (proc);
1815 struct lwp_info *leader_lp;
c3adc08c 1816
fa96cb38 1817 leader_lp = find_lwp_pid (pid_to_ptid (leader_pid));
c3adc08c 1818
fa96cb38
PA
1819 if (debug_threads)
1820 debug_printf ("leader_pid=%d, leader_lp!=NULL=%d, "
1821 "num_lwps=%d, zombie=%d\n",
1822 leader_pid, leader_lp!= NULL, num_lwps (leader_pid),
1823 linux_proc_pid_is_zombie (leader_pid));
1824
94585166 1825 if (leader_lp != NULL && !leader_lp->stopped
fa96cb38
PA
1826 /* Check if there are other threads in the group, as we may
1827 have raced with the inferior simply exiting. */
1828 && !last_thread_of_process_p (leader_pid)
1829 && linux_proc_pid_is_zombie (leader_pid))
1830 {
1831 /* A leader zombie can mean one of two things:
1832
1833 - It exited, and there's an exit status pending
1834 available, or only the leader exited (not the whole
1835 program). In the latter case, we can't waitpid the
1836 leader's exit status until all other threads are gone.
1837
1838 - There are 3 or more threads in the group, and a thread
1839 other than the leader exec'd. On an exec, the Linux
1840 kernel destroys all other threads (except the execing
1841 one) in the thread group, and resets the execing thread's
1842 tid to the tgid. No exit notification is sent for the
1843 execing thread -- from the ptracer's perspective, it
1844 appears as though the execing thread just vanishes.
1845 Until we reap all other threads except the leader and the
1846 execing thread, the leader will be zombie, and the
1847 execing thread will be in `D (disc sleep)'. As soon as
1848 all other threads are reaped, the execing thread changes
1849 it's tid to the tgid, and the previous (zombie) leader
1850 vanishes, giving place to the "new" leader. We could try
1851 distinguishing the exit and exec cases, by waiting once
1852 more, and seeing if something comes out, but it doesn't
1853 sound useful. The previous leader _does_ go away, and
1854 we'll re-add the new one once we see the exec event
1855 (which is just the same as what would happen if the
1856 previous leader did exit voluntarily before some other
1857 thread execs). */
c3adc08c 1858
fa96cb38
PA
1859 if (debug_threads)
1860 fprintf (stderr,
1861 "CZL: Thread group leader %d zombie "
1862 "(it exited, or another thread execd).\n",
1863 leader_pid);
c3adc08c 1864
fa96cb38 1865 delete_lwp (leader_lp);
c3adc08c
PA
1866 }
1867 }
fa96cb38 1868}
c3adc08c 1869
fa96cb38
PA
1870/* Callback for `find_inferior'. Returns the first LWP that is not
1871 stopped. ARG is a PTID filter. */
d50171e4 1872
fa96cb38
PA
1873static int
1874not_stopped_callback (struct inferior_list_entry *entry, void *arg)
1875{
1876 struct thread_info *thr = (struct thread_info *) entry;
1877 struct lwp_info *lwp;
1878 ptid_t filter = *(ptid_t *) arg;
47c0c975 1879
fa96cb38
PA
1880 if (!ptid_match (ptid_of (thr), filter))
1881 return 0;
bd99dc85 1882
fa96cb38
PA
1883 lwp = get_thread_lwp (thr);
1884 if (!lwp->stopped)
1885 return 1;
1886
1887 return 0;
0d62e5e8 1888}
611cb4a5 1889
863d01bd
PA
1890/* Increment LWP's suspend count. */
1891
1892static void
1893lwp_suspended_inc (struct lwp_info *lwp)
1894{
1895 lwp->suspended++;
1896
1897 if (debug_threads && lwp->suspended > 4)
1898 {
1899 struct thread_info *thread = get_lwp_thread (lwp);
1900
1901 debug_printf ("LWP %ld has a suspiciously high suspend count,"
1902 " suspended=%d\n", lwpid_of (thread), lwp->suspended);
1903 }
1904}
1905
1906/* Decrement LWP's suspend count. */
1907
1908static void
1909lwp_suspended_decr (struct lwp_info *lwp)
1910{
1911 lwp->suspended--;
1912
1913 if (lwp->suspended < 0)
1914 {
1915 struct thread_info *thread = get_lwp_thread (lwp);
1916
1917 internal_error (__FILE__, __LINE__,
1918 "unsuspend LWP %ld, suspended=%d\n", lwpid_of (thread),
1919 lwp->suspended);
1920 }
1921}
1922
219f2f23
PA
1923/* This function should only be called if the LWP got a SIGTRAP.
1924
1925 Handle any tracepoint steps or hits. Return true if a tracepoint
1926 event was handled, 0 otherwise. */
1927
1928static int
1929handle_tracepoints (struct lwp_info *lwp)
1930{
1931 struct thread_info *tinfo = get_lwp_thread (lwp);
1932 int tpoint_related_event = 0;
1933
582511be
PA
1934 gdb_assert (lwp->suspended == 0);
1935
7984d532
PA
1936 /* If this tracepoint hit causes a tracing stop, we'll immediately
1937 uninsert tracepoints. To do this, we temporarily pause all
1938 threads, unpatch away, and then unpause threads. We need to make
1939 sure the unpausing doesn't resume LWP too. */
863d01bd 1940 lwp_suspended_inc (lwp);
7984d532 1941
219f2f23
PA
1942 /* And we need to be sure that any all-threads-stopping doesn't try
1943 to move threads out of the jump pads, as it could deadlock the
1944 inferior (LWP could be in the jump pad, maybe even holding the
1945 lock.) */
1946
1947 /* Do any necessary step collect actions. */
1948 tpoint_related_event |= tracepoint_finished_step (tinfo, lwp->stop_pc);
1949
fa593d66
PA
1950 tpoint_related_event |= handle_tracepoint_bkpts (tinfo, lwp->stop_pc);
1951
219f2f23
PA
1952 /* See if we just hit a tracepoint and do its main collect
1953 actions. */
1954 tpoint_related_event |= tracepoint_was_hit (tinfo, lwp->stop_pc);
1955
863d01bd 1956 lwp_suspended_decr (lwp);
7984d532
PA
1957
1958 gdb_assert (lwp->suspended == 0);
fa593d66 1959 gdb_assert (!stabilizing_threads || lwp->collecting_fast_tracepoint);
7984d532 1960
219f2f23
PA
1961 if (tpoint_related_event)
1962 {
1963 if (debug_threads)
87ce2a04 1964 debug_printf ("got a tracepoint event\n");
219f2f23
PA
1965 return 1;
1966 }
1967
1968 return 0;
1969}
1970
fa593d66
PA
1971/* Convenience wrapper. Returns true if LWP is presently collecting a
1972 fast tracepoint. */
1973
1974static int
1975linux_fast_tracepoint_collecting (struct lwp_info *lwp,
1976 struct fast_tpoint_collect_status *status)
1977{
1978 CORE_ADDR thread_area;
d86d4aaf 1979 struct thread_info *thread = get_lwp_thread (lwp);
fa593d66
PA
1980
1981 if (the_low_target.get_thread_area == NULL)
1982 return 0;
1983
1984 /* Get the thread area address. This is used to recognize which
1985 thread is which when tracing with the in-process agent library.
1986 We don't read anything from the address, and treat it as opaque;
1987 it's the address itself that we assume is unique per-thread. */
d86d4aaf 1988 if ((*the_low_target.get_thread_area) (lwpid_of (thread), &thread_area) == -1)
fa593d66
PA
1989 return 0;
1990
1991 return fast_tracepoint_collecting (thread_area, lwp->stop_pc, status);
1992}
1993
1994/* The reason we resume in the caller, is because we want to be able
1995 to pass lwp->status_pending as WSTAT, and we need to clear
1996 status_pending_p before resuming, otherwise, linux_resume_one_lwp
1997 refuses to resume. */
1998
1999static int
2000maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat)
2001{
0bfdf32f 2002 struct thread_info *saved_thread;
fa593d66 2003
0bfdf32f
GB
2004 saved_thread = current_thread;
2005 current_thread = get_lwp_thread (lwp);
fa593d66
PA
2006
2007 if ((wstat == NULL
2008 || (WIFSTOPPED (*wstat) && WSTOPSIG (*wstat) != SIGTRAP))
2009 && supports_fast_tracepoints ()
58b4daa5 2010 && agent_loaded_p ())
fa593d66
PA
2011 {
2012 struct fast_tpoint_collect_status status;
2013 int r;
2014
2015 if (debug_threads)
87ce2a04
DE
2016 debug_printf ("Checking whether LWP %ld needs to move out of the "
2017 "jump pad.\n",
0bfdf32f 2018 lwpid_of (current_thread));
fa593d66
PA
2019
2020 r = linux_fast_tracepoint_collecting (lwp, &status);
2021
2022 if (wstat == NULL
2023 || (WSTOPSIG (*wstat) != SIGILL
2024 && WSTOPSIG (*wstat) != SIGFPE
2025 && WSTOPSIG (*wstat) != SIGSEGV
2026 && WSTOPSIG (*wstat) != SIGBUS))
2027 {
2028 lwp->collecting_fast_tracepoint = r;
2029
2030 if (r != 0)
2031 {
2032 if (r == 1 && lwp->exit_jump_pad_bkpt == NULL)
2033 {
2034 /* Haven't executed the original instruction yet.
2035 Set breakpoint there, and wait till it's hit,
2036 then single-step until exiting the jump pad. */
2037 lwp->exit_jump_pad_bkpt
2038 = set_breakpoint_at (status.adjusted_insn_addr, NULL);
2039 }
2040
2041 if (debug_threads)
87ce2a04
DE
2042 debug_printf ("Checking whether LWP %ld needs to move out of "
2043 "the jump pad...it does\n",
0bfdf32f
GB
2044 lwpid_of (current_thread));
2045 current_thread = saved_thread;
fa593d66
PA
2046
2047 return 1;
2048 }
2049 }
2050 else
2051 {
2052 /* If we get a synchronous signal while collecting, *and*
2053 while executing the (relocated) original instruction,
2054 reset the PC to point at the tpoint address, before
2055 reporting to GDB. Otherwise, it's an IPA lib bug: just
2056 report the signal to GDB, and pray for the best. */
2057
2058 lwp->collecting_fast_tracepoint = 0;
2059
2060 if (r != 0
2061 && (status.adjusted_insn_addr <= lwp->stop_pc
2062 && lwp->stop_pc < status.adjusted_insn_addr_end))
2063 {
2064 siginfo_t info;
2065 struct regcache *regcache;
2066
2067 /* The si_addr on a few signals references the address
2068 of the faulting instruction. Adjust that as
2069 well. */
2070 if ((WSTOPSIG (*wstat) == SIGILL
2071 || WSTOPSIG (*wstat) == SIGFPE
2072 || WSTOPSIG (*wstat) == SIGBUS
2073 || WSTOPSIG (*wstat) == SIGSEGV)
0bfdf32f 2074 && ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
b8e1b30e 2075 (PTRACE_TYPE_ARG3) 0, &info) == 0
fa593d66
PA
2076 /* Final check just to make sure we don't clobber
2077 the siginfo of non-kernel-sent signals. */
2078 && (uintptr_t) info.si_addr == lwp->stop_pc)
2079 {
2080 info.si_addr = (void *) (uintptr_t) status.tpoint_addr;
0bfdf32f 2081 ptrace (PTRACE_SETSIGINFO, lwpid_of (current_thread),
b8e1b30e 2082 (PTRACE_TYPE_ARG3) 0, &info);
fa593d66
PA
2083 }
2084
0bfdf32f 2085 regcache = get_thread_regcache (current_thread, 1);
fa593d66
PA
2086 (*the_low_target.set_pc) (regcache, status.tpoint_addr);
2087 lwp->stop_pc = status.tpoint_addr;
2088
2089 /* Cancel any fast tracepoint lock this thread was
2090 holding. */
2091 force_unlock_trace_buffer ();
2092 }
2093
2094 if (lwp->exit_jump_pad_bkpt != NULL)
2095 {
2096 if (debug_threads)
87ce2a04
DE
2097 debug_printf ("Cancelling fast exit-jump-pad: removing bkpt. "
2098 "stopping all threads momentarily.\n");
fa593d66
PA
2099
2100 stop_all_lwps (1, lwp);
fa593d66
PA
2101
2102 delete_breakpoint (lwp->exit_jump_pad_bkpt);
2103 lwp->exit_jump_pad_bkpt = NULL;
2104
2105 unstop_all_lwps (1, lwp);
2106
2107 gdb_assert (lwp->suspended >= 0);
2108 }
2109 }
2110 }
2111
2112 if (debug_threads)
87ce2a04
DE
2113 debug_printf ("Checking whether LWP %ld needs to move out of the "
2114 "jump pad...no\n",
0bfdf32f 2115 lwpid_of (current_thread));
0cccb683 2116
0bfdf32f 2117 current_thread = saved_thread;
fa593d66
PA
2118 return 0;
2119}
2120
2121/* Enqueue one signal in the "signals to report later when out of the
2122 jump pad" list. */
2123
2124static void
2125enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
2126{
2127 struct pending_signals *p_sig;
d86d4aaf 2128 struct thread_info *thread = get_lwp_thread (lwp);
fa593d66
PA
2129
2130 if (debug_threads)
87ce2a04 2131 debug_printf ("Deferring signal %d for LWP %ld.\n",
d86d4aaf 2132 WSTOPSIG (*wstat), lwpid_of (thread));
fa593d66
PA
2133
2134 if (debug_threads)
2135 {
2136 struct pending_signals *sig;
2137
2138 for (sig = lwp->pending_signals_to_report;
2139 sig != NULL;
2140 sig = sig->prev)
87ce2a04
DE
2141 debug_printf (" Already queued %d\n",
2142 sig->signal);
fa593d66 2143
87ce2a04 2144 debug_printf (" (no more currently queued signals)\n");
fa593d66
PA
2145 }
2146
1a981360
PA
2147 /* Don't enqueue non-RT signals if they are already in the deferred
2148 queue. (SIGSTOP being the easiest signal to see ending up here
2149 twice) */
2150 if (WSTOPSIG (*wstat) < __SIGRTMIN)
2151 {
2152 struct pending_signals *sig;
2153
2154 for (sig = lwp->pending_signals_to_report;
2155 sig != NULL;
2156 sig = sig->prev)
2157 {
2158 if (sig->signal == WSTOPSIG (*wstat))
2159 {
2160 if (debug_threads)
87ce2a04
DE
2161 debug_printf ("Not requeuing already queued non-RT signal %d"
2162 " for LWP %ld\n",
2163 sig->signal,
d86d4aaf 2164 lwpid_of (thread));
1a981360
PA
2165 return;
2166 }
2167 }
2168 }
2169
8d749320 2170 p_sig = XCNEW (struct pending_signals);
fa593d66
PA
2171 p_sig->prev = lwp->pending_signals_to_report;
2172 p_sig->signal = WSTOPSIG (*wstat);
8d749320 2173
d86d4aaf 2174 ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
56f7af9c 2175 &p_sig->info);
fa593d66
PA
2176
2177 lwp->pending_signals_to_report = p_sig;
2178}
2179
2180/* Dequeue one signal from the "signals to report later when out of
2181 the jump pad" list. */
2182
2183static int
2184dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
2185{
d86d4aaf
DE
2186 struct thread_info *thread = get_lwp_thread (lwp);
2187
fa593d66
PA
2188 if (lwp->pending_signals_to_report != NULL)
2189 {
2190 struct pending_signals **p_sig;
2191
2192 p_sig = &lwp->pending_signals_to_report;
2193 while ((*p_sig)->prev != NULL)
2194 p_sig = &(*p_sig)->prev;
2195
2196 *wstat = W_STOPCODE ((*p_sig)->signal);
2197 if ((*p_sig)->info.si_signo != 0)
d86d4aaf 2198 ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
56f7af9c 2199 &(*p_sig)->info);
fa593d66
PA
2200 free (*p_sig);
2201 *p_sig = NULL;
2202
2203 if (debug_threads)
87ce2a04 2204 debug_printf ("Reporting deferred signal %d for LWP %ld.\n",
d86d4aaf 2205 WSTOPSIG (*wstat), lwpid_of (thread));
fa593d66
PA
2206
2207 if (debug_threads)
2208 {
2209 struct pending_signals *sig;
2210
2211 for (sig = lwp->pending_signals_to_report;
2212 sig != NULL;
2213 sig = sig->prev)
87ce2a04
DE
2214 debug_printf (" Still queued %d\n",
2215 sig->signal);
fa593d66 2216
87ce2a04 2217 debug_printf (" (no more queued signals)\n");
fa593d66
PA
2218 }
2219
2220 return 1;
2221 }
2222
2223 return 0;
2224}
2225
582511be
PA
2226/* Fetch the possibly triggered data watchpoint info and store it in
2227 CHILD.
d50171e4 2228
582511be
PA
2229 On some archs, like x86, that use debug registers to set
2230 watchpoints, it's possible that the way to know which watched
2231 address trapped, is to check the register that is used to select
2232 which address to watch. Problem is, between setting the watchpoint
2233 and reading back which data address trapped, the user may change
2234 the set of watchpoints, and, as a consequence, GDB changes the
2235 debug registers in the inferior. To avoid reading back a stale
2236 stopped-data-address when that happens, we cache in LP the fact
2237 that a watchpoint trapped, and the corresponding data address, as
2238 soon as we see CHILD stop with a SIGTRAP. If GDB changes the debug
2239 registers meanwhile, we have the cached data we can rely on. */
d50171e4 2240
582511be
PA
2241static int
2242check_stopped_by_watchpoint (struct lwp_info *child)
2243{
2244 if (the_low_target.stopped_by_watchpoint != NULL)
d50171e4 2245 {
582511be 2246 struct thread_info *saved_thread;
d50171e4 2247
582511be
PA
2248 saved_thread = current_thread;
2249 current_thread = get_lwp_thread (child);
2250
2251 if (the_low_target.stopped_by_watchpoint ())
d50171e4 2252 {
15c66dd6 2253 child->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
582511be
PA
2254
2255 if (the_low_target.stopped_data_address != NULL)
2256 child->stopped_data_address
2257 = the_low_target.stopped_data_address ();
2258 else
2259 child->stopped_data_address = 0;
d50171e4
PA
2260 }
2261
0bfdf32f 2262 current_thread = saved_thread;
d50171e4
PA
2263 }
2264
15c66dd6 2265 return child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
c4d9ceb6
YQ
2266}
2267
de0d863e
DB
2268/* Return the ptrace options that we want to try to enable. */
2269
2270static int
2271linux_low_ptrace_options (int attached)
2272{
2273 int options = 0;
2274
2275 if (!attached)
2276 options |= PTRACE_O_EXITKILL;
2277
2278 if (report_fork_events)
2279 options |= PTRACE_O_TRACEFORK;
2280
c269dbdb
DB
2281 if (report_vfork_events)
2282 options |= (PTRACE_O_TRACEVFORK | PTRACE_O_TRACEVFORKDONE);
2283
94585166
DB
2284 if (report_exec_events)
2285 options |= PTRACE_O_TRACEEXEC;
2286
82075af2
JS
2287 options |= PTRACE_O_TRACESYSGOOD;
2288
de0d863e
DB
2289 return options;
2290}
2291
fa96cb38
PA
2292/* Do low-level handling of the event, and check if we should go on
2293 and pass it to caller code. Return the affected lwp if we are, or
2294 NULL otherwise. */
2295
2296static struct lwp_info *
582511be 2297linux_low_filter_event (int lwpid, int wstat)
fa96cb38
PA
2298{
2299 struct lwp_info *child;
2300 struct thread_info *thread;
582511be 2301 int have_stop_pc = 0;
fa96cb38
PA
2302
2303 child = find_lwp_pid (pid_to_ptid (lwpid));
2304
94585166
DB
2305 /* Check for stop events reported by a process we didn't already
2306 know about - anything not already in our LWP list.
2307
2308 If we're expecting to receive stopped processes after
2309 fork, vfork, and clone events, then we'll just add the
2310 new one to our list and go back to waiting for the event
2311 to be reported - the stopped process might be returned
2312 from waitpid before or after the event is.
2313
2314 But note the case of a non-leader thread exec'ing after the
2315 leader having exited, and gone from our lists (because
2316 check_zombie_leaders deleted it). The non-leader thread
2317 changes its tid to the tgid. */
2318
2319 if (WIFSTOPPED (wstat) && child == NULL && WSTOPSIG (wstat) == SIGTRAP
2320 && linux_ptrace_get_extended_event (wstat) == PTRACE_EVENT_EXEC)
2321 {
2322 ptid_t child_ptid;
2323
2324 /* A multi-thread exec after we had seen the leader exiting. */
2325 if (debug_threads)
2326 {
2327 debug_printf ("LLW: Re-adding thread group leader LWP %d"
2328 "after exec.\n", lwpid);
2329 }
2330
2331 child_ptid = ptid_build (lwpid, lwpid, 0);
2332 child = add_lwp (child_ptid);
2333 child->stopped = 1;
2334 current_thread = child->thread;
2335 }
2336
fa96cb38
PA
2337 /* If we didn't find a process, one of two things presumably happened:
2338 - A process we started and then detached from has exited. Ignore it.
2339 - A process we are controlling has forked and the new child's stop
2340 was reported to us by the kernel. Save its PID. */
2341 if (child == NULL && WIFSTOPPED (wstat))
2342 {
2343 add_to_pid_list (&stopped_pids, lwpid, wstat);
2344 return NULL;
2345 }
2346 else if (child == NULL)
2347 return NULL;
2348
2349 thread = get_lwp_thread (child);
2350
2351 child->stopped = 1;
2352
2353 child->last_status = wstat;
2354
582511be
PA
2355 /* Check if the thread has exited. */
2356 if ((WIFEXITED (wstat) || WIFSIGNALED (wstat)))
2357 {
2358 if (debug_threads)
2359 debug_printf ("LLFE: %d exited.\n", lwpid);
65706a29
PA
2360 /* If there is at least one more LWP, then the exit signal was
2361 not the end of the debugged application and should be
2362 ignored, unless GDB wants to hear about thread exits. */
2363 if (report_thread_events
2364 || last_thread_of_process_p (pid_of (thread)))
582511be 2365 {
65706a29
PA
2366 /* Since events are serialized to GDB core, and we can't
2367 report this one right now. Leave the status pending for
2368 the next time we're able to report it. */
2369 mark_lwp_dead (child, wstat);
2370 return child;
582511be
PA
2371 }
2372 else
2373 {
65706a29
PA
2374 delete_lwp (child);
2375 return NULL;
582511be
PA
2376 }
2377 }
2378
2379 gdb_assert (WIFSTOPPED (wstat));
2380
fa96cb38
PA
2381 if (WIFSTOPPED (wstat))
2382 {
2383 struct process_info *proc;
2384
c06cbd92 2385 /* Architecture-specific setup after inferior is running. */
fa96cb38 2386 proc = find_process_pid (pid_of (thread));
c06cbd92 2387 if (proc->tdesc == NULL)
fa96cb38 2388 {
c06cbd92
YQ
2389 if (proc->attached)
2390 {
c06cbd92
YQ
2391 /* This needs to happen after we have attached to the
2392 inferior and it is stopped for the first time, but
2393 before we access any inferior registers. */
94585166 2394 linux_arch_setup_thread (thread);
c06cbd92
YQ
2395 }
2396 else
2397 {
2398 /* The process is started, but GDBserver will do
2399 architecture-specific setup after the program stops at
2400 the first instruction. */
2401 child->status_pending_p = 1;
2402 child->status_pending = wstat;
2403 return child;
2404 }
fa96cb38
PA
2405 }
2406 }
2407
fa96cb38
PA
2408 if (WIFSTOPPED (wstat) && child->must_set_ptrace_flags)
2409 {
beed38b8 2410 struct process_info *proc = find_process_pid (pid_of (thread));
de0d863e 2411 int options = linux_low_ptrace_options (proc->attached);
beed38b8 2412
de0d863e 2413 linux_enable_event_reporting (lwpid, options);
fa96cb38
PA
2414 child->must_set_ptrace_flags = 0;
2415 }
2416
82075af2
JS
2417 /* Always update syscall_state, even if it will be filtered later. */
2418 if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SYSCALL_SIGTRAP)
2419 {
2420 child->syscall_state
2421 = (child->syscall_state == TARGET_WAITKIND_SYSCALL_ENTRY
2422 ? TARGET_WAITKIND_SYSCALL_RETURN
2423 : TARGET_WAITKIND_SYSCALL_ENTRY);
2424 }
2425 else
2426 {
2427 /* Almost all other ptrace-stops are known to be outside of system
2428 calls, with further exceptions in handle_extended_wait. */
2429 child->syscall_state = TARGET_WAITKIND_IGNORE;
2430 }
2431
e7ad2f14
PA
2432 /* Be careful to not overwrite stop_pc until save_stop_reason is
2433 called. */
fa96cb38 2434 if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGTRAP
89a5711c 2435 && linux_is_extended_waitstatus (wstat))
fa96cb38 2436 {
582511be 2437 child->stop_pc = get_pc (child);
94585166 2438 if (handle_extended_wait (&child, wstat))
de0d863e
DB
2439 {
2440 /* The event has been handled, so just return without
2441 reporting it. */
2442 return NULL;
2443 }
fa96cb38
PA
2444 }
2445
80aea927 2446 if (linux_wstatus_maybe_breakpoint (wstat))
582511be 2447 {
e7ad2f14 2448 if (save_stop_reason (child))
582511be
PA
2449 have_stop_pc = 1;
2450 }
2451
2452 if (!have_stop_pc)
2453 child->stop_pc = get_pc (child);
2454
fa96cb38
PA
2455 if (WIFSTOPPED (wstat) && WSTOPSIG (wstat) == SIGSTOP
2456 && child->stop_expected)
2457 {
2458 if (debug_threads)
2459 debug_printf ("Expected stop.\n");
2460 child->stop_expected = 0;
2461
2462 if (thread->last_resume_kind == resume_stop)
2463 {
2464 /* We want to report the stop to the core. Treat the
2465 SIGSTOP as a normal event. */
2bf6fb9d
PA
2466 if (debug_threads)
2467 debug_printf ("LLW: resume_stop SIGSTOP caught for %s.\n",
2468 target_pid_to_str (ptid_of (thread)));
fa96cb38
PA
2469 }
2470 else if (stopping_threads != NOT_STOPPING_THREADS)
2471 {
2472 /* Stopping threads. We don't want this SIGSTOP to end up
582511be 2473 pending. */
2bf6fb9d
PA
2474 if (debug_threads)
2475 debug_printf ("LLW: SIGSTOP caught for %s "
2476 "while stopping threads.\n",
2477 target_pid_to_str (ptid_of (thread)));
fa96cb38
PA
2478 return NULL;
2479 }
2480 else
2481 {
2bf6fb9d
PA
2482 /* This is a delayed SIGSTOP. Filter out the event. */
2483 if (debug_threads)
2484 debug_printf ("LLW: %s %s, 0, 0 (discard delayed SIGSTOP)\n",
2485 child->stepping ? "step" : "continue",
2486 target_pid_to_str (ptid_of (thread)));
2487
fa96cb38
PA
2488 linux_resume_one_lwp (child, child->stepping, 0, NULL);
2489 return NULL;
2490 }
2491 }
2492
582511be
PA
2493 child->status_pending_p = 1;
2494 child->status_pending = wstat;
fa96cb38
PA
2495 return child;
2496}
2497
20ba1ce6
PA
2498/* Resume LWPs that are currently stopped without any pending status
2499 to report, but are resumed from the core's perspective. */
2500
2501static void
2502resume_stopped_resumed_lwps (struct inferior_list_entry *entry)
2503{
2504 struct thread_info *thread = (struct thread_info *) entry;
2505 struct lwp_info *lp = get_thread_lwp (thread);
2506
2507 if (lp->stopped
863d01bd 2508 && !lp->suspended
20ba1ce6 2509 && !lp->status_pending_p
20ba1ce6
PA
2510 && thread->last_status.kind == TARGET_WAITKIND_IGNORE)
2511 {
2512 int step = thread->last_resume_kind == resume_step;
2513
2514 if (debug_threads)
2515 debug_printf ("RSRL: resuming stopped-resumed LWP %s at %s: step=%d\n",
2516 target_pid_to_str (ptid_of (thread)),
2517 paddress (lp->stop_pc),
2518 step);
2519
2520 linux_resume_one_lwp (lp, step, GDB_SIGNAL_0, NULL);
2521 }
2522}
2523
fa96cb38
PA
2524/* Wait for an event from child(ren) WAIT_PTID, and return any that
2525 match FILTER_PTID (leaving others pending). The PTIDs can be:
2526 minus_one_ptid, to specify any child; a pid PTID, specifying all
2527 lwps of a thread group; or a PTID representing a single lwp. Store
2528 the stop status through the status pointer WSTAT. OPTIONS is
2529 passed to the waitpid call. Return 0 if no event was found and
2530 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
2531 was found. Return the PID of the stopped child otherwise. */
bd99dc85 2532
0d62e5e8 2533static int
fa96cb38
PA
2534linux_wait_for_event_filtered (ptid_t wait_ptid, ptid_t filter_ptid,
2535 int *wstatp, int options)
0d62e5e8 2536{
d86d4aaf 2537 struct thread_info *event_thread;
d50171e4 2538 struct lwp_info *event_child, *requested_child;
fa96cb38 2539 sigset_t block_mask, prev_mask;
d50171e4 2540
fa96cb38 2541 retry:
d86d4aaf
DE
2542 /* N.B. event_thread points to the thread_info struct that contains
2543 event_child. Keep them in sync. */
2544 event_thread = NULL;
d50171e4
PA
2545 event_child = NULL;
2546 requested_child = NULL;
0d62e5e8 2547
95954743 2548 /* Check for a lwp with a pending status. */
bd99dc85 2549
fa96cb38 2550 if (ptid_equal (filter_ptid, minus_one_ptid) || ptid_is_pid (filter_ptid))
0d62e5e8 2551 {
d86d4aaf 2552 event_thread = (struct thread_info *)
fa96cb38 2553 find_inferior (&all_threads, status_pending_p_callback, &filter_ptid);
d86d4aaf
DE
2554 if (event_thread != NULL)
2555 event_child = get_thread_lwp (event_thread);
2556 if (debug_threads && event_thread)
2557 debug_printf ("Got a pending child %ld\n", lwpid_of (event_thread));
0d62e5e8 2558 }
fa96cb38 2559 else if (!ptid_equal (filter_ptid, null_ptid))
0d62e5e8 2560 {
fa96cb38 2561 requested_child = find_lwp_pid (filter_ptid);
d50171e4 2562
bde24c0a 2563 if (stopping_threads == NOT_STOPPING_THREADS
fa593d66
PA
2564 && requested_child->status_pending_p
2565 && requested_child->collecting_fast_tracepoint)
2566 {
2567 enqueue_one_deferred_signal (requested_child,
2568 &requested_child->status_pending);
2569 requested_child->status_pending_p = 0;
2570 requested_child->status_pending = 0;
2571 linux_resume_one_lwp (requested_child, 0, 0, NULL);
2572 }
2573
2574 if (requested_child->suspended
2575 && requested_child->status_pending_p)
38e08fca
GB
2576 {
2577 internal_error (__FILE__, __LINE__,
2578 "requesting an event out of a"
2579 " suspended child?");
2580 }
fa593d66 2581
d50171e4 2582 if (requested_child->status_pending_p)
d86d4aaf
DE
2583 {
2584 event_child = requested_child;
2585 event_thread = get_lwp_thread (event_child);
2586 }
0d62e5e8 2587 }
611cb4a5 2588
0d62e5e8
DJ
2589 if (event_child != NULL)
2590 {
bd99dc85 2591 if (debug_threads)
87ce2a04 2592 debug_printf ("Got an event from pending child %ld (%04x)\n",
d86d4aaf 2593 lwpid_of (event_thread), event_child->status_pending);
fa96cb38 2594 *wstatp = event_child->status_pending;
bd99dc85
PA
2595 event_child->status_pending_p = 0;
2596 event_child->status_pending = 0;
0bfdf32f 2597 current_thread = event_thread;
d86d4aaf 2598 return lwpid_of (event_thread);
0d62e5e8
DJ
2599 }
2600
fa96cb38
PA
2601 /* But if we don't find a pending event, we'll have to wait.
2602
2603 We only enter this loop if no process has a pending wait status.
2604 Thus any action taken in response to a wait status inside this
2605 loop is responding as soon as we detect the status, not after any
2606 pending events. */
d8301ad1 2607
fa96cb38
PA
2608 /* Make sure SIGCHLD is blocked until the sigsuspend below. Block
2609 all signals while here. */
2610 sigfillset (&block_mask);
2611 sigprocmask (SIG_BLOCK, &block_mask, &prev_mask);
2612
582511be
PA
2613 /* Always pull all events out of the kernel. We'll randomly select
2614 an event LWP out of all that have events, to prevent
2615 starvation. */
fa96cb38 2616 while (event_child == NULL)
0d62e5e8 2617 {
fa96cb38 2618 pid_t ret = 0;
0d62e5e8 2619
fa96cb38
PA
2620 /* Always use -1 and WNOHANG, due to couple of a kernel/ptrace
2621 quirks:
0d62e5e8 2622
fa96cb38
PA
2623 - If the thread group leader exits while other threads in the
2624 thread group still exist, waitpid(TGID, ...) hangs. That
2625 waitpid won't return an exit status until the other threads
2626 in the group are reaped.
611cb4a5 2627
fa96cb38
PA
2628 - When a non-leader thread execs, that thread just vanishes
2629 without reporting an exit (so we'd hang if we waited for it
2630 explicitly in that case). The exec event is reported to
94585166 2631 the TGID pid. */
fa96cb38
PA
2632 errno = 0;
2633 ret = my_waitpid (-1, wstatp, options | WNOHANG);
d8301ad1 2634
fa96cb38
PA
2635 if (debug_threads)
2636 debug_printf ("LWFE: waitpid(-1, ...) returned %d, %s\n",
2637 ret, errno ? strerror (errno) : "ERRNO-OK");
0d62e5e8 2638
fa96cb38 2639 if (ret > 0)
0d62e5e8 2640 {
89be2091 2641 if (debug_threads)
bd99dc85 2642 {
fa96cb38
PA
2643 debug_printf ("LLW: waitpid %ld received %s\n",
2644 (long) ret, status_to_str (*wstatp));
bd99dc85 2645 }
89be2091 2646
582511be
PA
2647 /* Filter all events. IOW, leave all events pending. We'll
2648 randomly select an event LWP out of all that have events
2649 below. */
2650 linux_low_filter_event (ret, *wstatp);
fa96cb38
PA
2651 /* Retry until nothing comes out of waitpid. A single
2652 SIGCHLD can indicate more than one child stopped. */
89be2091
DJ
2653 continue;
2654 }
2655
20ba1ce6
PA
2656 /* Now that we've pulled all events out of the kernel, resume
2657 LWPs that don't have an interesting event to report. */
2658 if (stopping_threads == NOT_STOPPING_THREADS)
2659 for_each_inferior (&all_threads, resume_stopped_resumed_lwps);
2660
2661 /* ... and find an LWP with a status to report to the core, if
2662 any. */
582511be
PA
2663 event_thread = (struct thread_info *)
2664 find_inferior (&all_threads, status_pending_p_callback, &filter_ptid);
2665 if (event_thread != NULL)
2666 {
2667 event_child = get_thread_lwp (event_thread);
2668 *wstatp = event_child->status_pending;
2669 event_child->status_pending_p = 0;
2670 event_child->status_pending = 0;
2671 break;
2672 }
2673
fa96cb38
PA
2674 /* Check for zombie thread group leaders. Those can't be reaped
2675 until all other threads in the thread group are. */
2676 check_zombie_leaders ();
2677
2678 /* If there are no resumed children left in the set of LWPs we
2679 want to wait for, bail. We can't just block in
2680 waitpid/sigsuspend, because lwps might have been left stopped
2681 in trace-stop state, and we'd be stuck forever waiting for
2682 their status to change (which would only happen if we resumed
2683 them). Even if WNOHANG is set, this return code is preferred
2684 over 0 (below), as it is more detailed. */
2685 if ((find_inferior (&all_threads,
2686 not_stopped_callback,
2687 &wait_ptid) == NULL))
a6dbe5df 2688 {
fa96cb38
PA
2689 if (debug_threads)
2690 debug_printf ("LLW: exit (no unwaited-for LWP)\n");
2691 sigprocmask (SIG_SETMASK, &prev_mask, NULL);
2692 return -1;
a6dbe5df
PA
2693 }
2694
fa96cb38
PA
2695 /* No interesting event to report to the caller. */
2696 if ((options & WNOHANG))
24a09b5f 2697 {
fa96cb38
PA
2698 if (debug_threads)
2699 debug_printf ("WNOHANG set, no event found\n");
2700
2701 sigprocmask (SIG_SETMASK, &prev_mask, NULL);
2702 return 0;
24a09b5f
DJ
2703 }
2704
fa96cb38
PA
2705 /* Block until we get an event reported with SIGCHLD. */
2706 if (debug_threads)
2707 debug_printf ("sigsuspend'ing\n");
d50171e4 2708
fa96cb38
PA
2709 sigsuspend (&prev_mask);
2710 sigprocmask (SIG_SETMASK, &prev_mask, NULL);
2711 goto retry;
2712 }
d50171e4 2713
fa96cb38 2714 sigprocmask (SIG_SETMASK, &prev_mask, NULL);
d50171e4 2715
0bfdf32f 2716 current_thread = event_thread;
d50171e4 2717
fa96cb38
PA
2718 return lwpid_of (event_thread);
2719}
2720
2721/* Wait for an event from child(ren) PTID. PTIDs can be:
2722 minus_one_ptid, to specify any child; a pid PTID, specifying all
2723 lwps of a thread group; or a PTID representing a single lwp. Store
2724 the stop status through the status pointer WSTAT. OPTIONS is
2725 passed to the waitpid call. Return 0 if no event was found and
2726 OPTIONS contains WNOHANG. Return -1 if no unwaited-for children
2727 was found. Return the PID of the stopped child otherwise. */
2728
2729static int
2730linux_wait_for_event (ptid_t ptid, int *wstatp, int options)
2731{
2732 return linux_wait_for_event_filtered (ptid, ptid, wstatp, options);
611cb4a5
DJ
2733}
2734
6bf5e0ba
PA
2735/* Count the LWP's that have had events. */
2736
2737static int
2738count_events_callback (struct inferior_list_entry *entry, void *data)
2739{
d86d4aaf 2740 struct thread_info *thread = (struct thread_info *) entry;
8bf3b159 2741 struct lwp_info *lp = get_thread_lwp (thread);
9a3c8263 2742 int *count = (int *) data;
6bf5e0ba
PA
2743
2744 gdb_assert (count != NULL);
2745
582511be 2746 /* Count only resumed LWPs that have an event pending. */
8336d594 2747 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
8bf3b159 2748 && lp->status_pending_p)
6bf5e0ba
PA
2749 (*count)++;
2750
2751 return 0;
2752}
2753
2754/* Select the LWP (if any) that is currently being single-stepped. */
2755
2756static int
2757select_singlestep_lwp_callback (struct inferior_list_entry *entry, void *data)
2758{
d86d4aaf
DE
2759 struct thread_info *thread = (struct thread_info *) entry;
2760 struct lwp_info *lp = get_thread_lwp (thread);
6bf5e0ba 2761
8336d594
PA
2762 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
2763 && thread->last_resume_kind == resume_step
6bf5e0ba
PA
2764 && lp->status_pending_p)
2765 return 1;
2766 else
2767 return 0;
2768}
2769
b90fc188 2770/* Select the Nth LWP that has had an event. */
6bf5e0ba
PA
2771
2772static int
2773select_event_lwp_callback (struct inferior_list_entry *entry, void *data)
2774{
d86d4aaf 2775 struct thread_info *thread = (struct thread_info *) entry;
8bf3b159 2776 struct lwp_info *lp = get_thread_lwp (thread);
9a3c8263 2777 int *selector = (int *) data;
6bf5e0ba
PA
2778
2779 gdb_assert (selector != NULL);
2780
582511be 2781 /* Select only resumed LWPs that have an event pending. */
91baf43f 2782 if (thread->last_status.kind == TARGET_WAITKIND_IGNORE
8bf3b159 2783 && lp->status_pending_p)
6bf5e0ba
PA
2784 if ((*selector)-- == 0)
2785 return 1;
2786
2787 return 0;
2788}
2789
6bf5e0ba
PA
2790/* Select one LWP out of those that have events pending. */
2791
2792static void
2793select_event_lwp (struct lwp_info **orig_lp)
2794{
2795 int num_events = 0;
2796 int random_selector;
582511be
PA
2797 struct thread_info *event_thread = NULL;
2798
2799 /* In all-stop, give preference to the LWP that is being
2800 single-stepped. There will be at most one, and it's the LWP that
2801 the core is most interested in. If we didn't do this, then we'd
2802 have to handle pending step SIGTRAPs somehow in case the core
2803 later continues the previously-stepped thread, otherwise we'd
2804 report the pending SIGTRAP, and the core, not having stepped the
2805 thread, wouldn't understand what the trap was for, and therefore
2806 would report it to the user as a random signal. */
2807 if (!non_stop)
6bf5e0ba 2808 {
582511be
PA
2809 event_thread
2810 = (struct thread_info *) find_inferior (&all_threads,
2811 select_singlestep_lwp_callback,
2812 NULL);
2813 if (event_thread != NULL)
2814 {
2815 if (debug_threads)
2816 debug_printf ("SEL: Select single-step %s\n",
2817 target_pid_to_str (ptid_of (event_thread)));
2818 }
6bf5e0ba 2819 }
582511be 2820 if (event_thread == NULL)
6bf5e0ba
PA
2821 {
2822 /* No single-stepping LWP. Select one at random, out of those
b90fc188 2823 which have had events. */
6bf5e0ba 2824
b90fc188 2825 /* First see how many events we have. */
d86d4aaf 2826 find_inferior (&all_threads, count_events_callback, &num_events);
8bf3b159 2827 gdb_assert (num_events > 0);
6bf5e0ba 2828
b90fc188
PA
2829 /* Now randomly pick a LWP out of those that have had
2830 events. */
6bf5e0ba
PA
2831 random_selector = (int)
2832 ((num_events * (double) rand ()) / (RAND_MAX + 1.0));
2833
2834 if (debug_threads && num_events > 1)
87ce2a04
DE
2835 debug_printf ("SEL: Found %d SIGTRAP events, selecting #%d\n",
2836 num_events, random_selector);
6bf5e0ba 2837
d86d4aaf
DE
2838 event_thread
2839 = (struct thread_info *) find_inferior (&all_threads,
2840 select_event_lwp_callback,
2841 &random_selector);
6bf5e0ba
PA
2842 }
2843
d86d4aaf 2844 if (event_thread != NULL)
6bf5e0ba 2845 {
d86d4aaf
DE
2846 struct lwp_info *event_lp = get_thread_lwp (event_thread);
2847
6bf5e0ba
PA
2848 /* Switch the event LWP. */
2849 *orig_lp = event_lp;
2850 }
2851}
2852
7984d532
PA
2853/* Decrement the suspend count of an LWP. */
2854
2855static int
2856unsuspend_one_lwp (struct inferior_list_entry *entry, void *except)
2857{
d86d4aaf
DE
2858 struct thread_info *thread = (struct thread_info *) entry;
2859 struct lwp_info *lwp = get_thread_lwp (thread);
7984d532
PA
2860
2861 /* Ignore EXCEPT. */
2862 if (lwp == except)
2863 return 0;
2864
863d01bd 2865 lwp_suspended_decr (lwp);
7984d532
PA
2866 return 0;
2867}
2868
2869/* Decrement the suspend count of all LWPs, except EXCEPT, if non
2870 NULL. */
2871
2872static void
2873unsuspend_all_lwps (struct lwp_info *except)
2874{
d86d4aaf 2875 find_inferior (&all_threads, unsuspend_one_lwp, except);
7984d532
PA
2876}
2877
fa593d66
PA
2878static void move_out_of_jump_pad_callback (struct inferior_list_entry *entry);
2879static int stuck_in_jump_pad_callback (struct inferior_list_entry *entry,
2880 void *data);
2881static int lwp_running (struct inferior_list_entry *entry, void *data);
2882static ptid_t linux_wait_1 (ptid_t ptid,
2883 struct target_waitstatus *ourstatus,
2884 int target_options);
2885
2886/* Stabilize threads (move out of jump pads).
2887
2888 If a thread is midway collecting a fast tracepoint, we need to
2889 finish the collection and move it out of the jump pad before
2890 reporting the signal.
2891
2892 This avoids recursion while collecting (when a signal arrives
2893 midway, and the signal handler itself collects), which would trash
2894 the trace buffer. In case the user set a breakpoint in a signal
2895 handler, this avoids the backtrace showing the jump pad, etc..
2896 Most importantly, there are certain things we can't do safely if
2897 threads are stopped in a jump pad (or in its callee's). For
2898 example:
2899
2900 - starting a new trace run. A thread still collecting the
2901 previous run, could trash the trace buffer when resumed. The trace
2902 buffer control structures would have been reset but the thread had
2903 no way to tell. The thread could even midway memcpy'ing to the
2904 buffer, which would mean that when resumed, it would clobber the
2905 trace buffer that had been set for a new run.
2906
2907 - we can't rewrite/reuse the jump pads for new tracepoints
2908 safely. Say you do tstart while a thread is stopped midway while
2909 collecting. When the thread is later resumed, it finishes the
2910 collection, and returns to the jump pad, to execute the original
2911 instruction that was under the tracepoint jump at the time the
2912 older run had been started. If the jump pad had been rewritten
2913 since for something else in the new run, the thread would now
2914 execute the wrong / random instructions. */
2915
2916static void
2917linux_stabilize_threads (void)
2918{
0bfdf32f 2919 struct thread_info *saved_thread;
d86d4aaf 2920 struct thread_info *thread_stuck;
fa593d66 2921
d86d4aaf
DE
2922 thread_stuck
2923 = (struct thread_info *) find_inferior (&all_threads,
2924 stuck_in_jump_pad_callback,
2925 NULL);
2926 if (thread_stuck != NULL)
fa593d66 2927 {
b4d51a55 2928 if (debug_threads)
87ce2a04 2929 debug_printf ("can't stabilize, LWP %ld is stuck in jump pad\n",
d86d4aaf 2930 lwpid_of (thread_stuck));
fa593d66
PA
2931 return;
2932 }
2933
0bfdf32f 2934 saved_thread = current_thread;
fa593d66
PA
2935
2936 stabilizing_threads = 1;
2937
2938 /* Kick 'em all. */
d86d4aaf 2939 for_each_inferior (&all_threads, move_out_of_jump_pad_callback);
fa593d66
PA
2940
2941 /* Loop until all are stopped out of the jump pads. */
d86d4aaf 2942 while (find_inferior (&all_threads, lwp_running, NULL) != NULL)
fa593d66
PA
2943 {
2944 struct target_waitstatus ourstatus;
2945 struct lwp_info *lwp;
fa593d66
PA
2946 int wstat;
2947
2948 /* Note that we go through the full wait even loop. While
2949 moving threads out of jump pad, we need to be able to step
2950 over internal breakpoints and such. */
32fcada3 2951 linux_wait_1 (minus_one_ptid, &ourstatus, 0);
fa593d66
PA
2952
2953 if (ourstatus.kind == TARGET_WAITKIND_STOPPED)
2954 {
0bfdf32f 2955 lwp = get_thread_lwp (current_thread);
fa593d66
PA
2956
2957 /* Lock it. */
863d01bd 2958 lwp_suspended_inc (lwp);
fa593d66 2959
a493e3e2 2960 if (ourstatus.value.sig != GDB_SIGNAL_0
0bfdf32f 2961 || current_thread->last_resume_kind == resume_stop)
fa593d66 2962 {
2ea28649 2963 wstat = W_STOPCODE (gdb_signal_to_host (ourstatus.value.sig));
fa593d66
PA
2964 enqueue_one_deferred_signal (lwp, &wstat);
2965 }
2966 }
2967 }
2968
d86d4aaf 2969 find_inferior (&all_threads, unsuspend_one_lwp, NULL);
fa593d66
PA
2970
2971 stabilizing_threads = 0;
2972
0bfdf32f 2973 current_thread = saved_thread;
fa593d66 2974
b4d51a55 2975 if (debug_threads)
fa593d66 2976 {
d86d4aaf
DE
2977 thread_stuck
2978 = (struct thread_info *) find_inferior (&all_threads,
2979 stuck_in_jump_pad_callback,
2980 NULL);
2981 if (thread_stuck != NULL)
87ce2a04 2982 debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n",
d86d4aaf 2983 lwpid_of (thread_stuck));
fa593d66
PA
2984 }
2985}
2986
582511be
PA
2987/* Convenience function that is called when the kernel reports an
2988 event that is not passed out to GDB. */
2989
2990static ptid_t
2991ignore_event (struct target_waitstatus *ourstatus)
2992{
2993 /* If we got an event, there may still be others, as a single
2994 SIGCHLD can indicate more than one child stopped. This forces
2995 another target_wait call. */
2996 async_file_mark ();
2997
2998 ourstatus->kind = TARGET_WAITKIND_IGNORE;
2999 return null_ptid;
3000}
3001
65706a29
PA
3002/* Convenience function that is called when the kernel reports an exit
3003 event. This decides whether to report the event to GDB as a
3004 process exit event, a thread exit event, or to suppress the
3005 event. */
3006
3007static ptid_t
3008filter_exit_event (struct lwp_info *event_child,
3009 struct target_waitstatus *ourstatus)
3010{
3011 struct thread_info *thread = get_lwp_thread (event_child);
3012 ptid_t ptid = ptid_of (thread);
3013
3014 if (!last_thread_of_process_p (pid_of (thread)))
3015 {
3016 if (report_thread_events)
3017 ourstatus->kind = TARGET_WAITKIND_THREAD_EXITED;
3018 else
3019 ourstatus->kind = TARGET_WAITKIND_IGNORE;
3020
3021 delete_lwp (event_child);
3022 }
3023 return ptid;
3024}
3025
82075af2
JS
3026/* Returns 1 if GDB is interested in any event_child syscalls. */
3027
3028static int
3029gdb_catching_syscalls_p (struct lwp_info *event_child)
3030{
3031 struct thread_info *thread = get_lwp_thread (event_child);
3032 struct process_info *proc = get_thread_process (thread);
3033
3034 return !VEC_empty (int, proc->syscalls_to_catch);
3035}
3036
3037/* Returns 1 if GDB is interested in the event_child syscall.
3038 Only to be called when stopped reason is SYSCALL_SIGTRAP. */
3039
3040static int
3041gdb_catch_this_syscall_p (struct lwp_info *event_child)
3042{
3043 int i, iter;
3044 int sysno, sysret;
3045 struct thread_info *thread = get_lwp_thread (event_child);
3046 struct process_info *proc = get_thread_process (thread);
3047
3048 if (VEC_empty (int, proc->syscalls_to_catch))
3049 return 0;
3050
3051 if (VEC_index (int, proc->syscalls_to_catch, 0) == ANY_SYSCALL)
3052 return 1;
3053
3054 get_syscall_trapinfo (event_child, &sysno, &sysret);
3055 for (i = 0;
3056 VEC_iterate (int, proc->syscalls_to_catch, i, iter);
3057 i++)
3058 if (iter == sysno)
3059 return 1;
3060
3061 return 0;
3062}
3063
0d62e5e8 3064/* Wait for process, returns status. */
da6d8c04 3065
95954743
PA
3066static ptid_t
3067linux_wait_1 (ptid_t ptid,
3068 struct target_waitstatus *ourstatus, int target_options)
da6d8c04 3069{
e5f1222d 3070 int w;
fc7238bb 3071 struct lwp_info *event_child;
bd99dc85 3072 int options;
bd99dc85 3073 int pid;
6bf5e0ba
PA
3074 int step_over_finished;
3075 int bp_explains_trap;
3076 int maybe_internal_trap;
3077 int report_to_gdb;
219f2f23 3078 int trace_event;
c2d6af84 3079 int in_step_range;
f2faf941 3080 int any_resumed;
bd99dc85 3081
87ce2a04
DE
3082 if (debug_threads)
3083 {
3084 debug_enter ();
3085 debug_printf ("linux_wait_1: [%s]\n", target_pid_to_str (ptid));
3086 }
3087
bd99dc85
PA
3088 /* Translate generic target options into linux options. */
3089 options = __WALL;
3090 if (target_options & TARGET_WNOHANG)
3091 options |= WNOHANG;
0d62e5e8 3092
fa593d66
PA
3093 bp_explains_trap = 0;
3094 trace_event = 0;
c2d6af84 3095 in_step_range = 0;
bd99dc85
PA
3096 ourstatus->kind = TARGET_WAITKIND_IGNORE;
3097
f2faf941
PA
3098 /* Find a resumed LWP, if any. */
3099 if (find_inferior (&all_threads,
3100 status_pending_p_callback,
3101 &minus_one_ptid) != NULL)
3102 any_resumed = 1;
3103 else if ((find_inferior (&all_threads,
3104 not_stopped_callback,
3105 &minus_one_ptid) != NULL))
3106 any_resumed = 1;
3107 else
3108 any_resumed = 0;
3109
6bf5e0ba
PA
3110 if (ptid_equal (step_over_bkpt, null_ptid))
3111 pid = linux_wait_for_event (ptid, &w, options);
3112 else
3113 {
3114 if (debug_threads)
87ce2a04
DE
3115 debug_printf ("step_over_bkpt set [%s], doing a blocking wait\n",
3116 target_pid_to_str (step_over_bkpt));
6bf5e0ba
PA
3117 pid = linux_wait_for_event (step_over_bkpt, &w, options & ~WNOHANG);
3118 }
3119
f2faf941 3120 if (pid == 0 || (pid == -1 && !any_resumed))
87ce2a04 3121 {
fa96cb38
PA
3122 gdb_assert (target_options & TARGET_WNOHANG);
3123
87ce2a04
DE
3124 if (debug_threads)
3125 {
fa96cb38
PA
3126 debug_printf ("linux_wait_1 ret = null_ptid, "
3127 "TARGET_WAITKIND_IGNORE\n");
87ce2a04
DE
3128 debug_exit ();
3129 }
fa96cb38
PA
3130
3131 ourstatus->kind = TARGET_WAITKIND_IGNORE;
87ce2a04
DE
3132 return null_ptid;
3133 }
fa96cb38
PA
3134 else if (pid == -1)
3135 {
3136 if (debug_threads)
3137 {
3138 debug_printf ("linux_wait_1 ret = null_ptid, "
3139 "TARGET_WAITKIND_NO_RESUMED\n");
3140 debug_exit ();
3141 }
bd99dc85 3142
fa96cb38
PA
3143 ourstatus->kind = TARGET_WAITKIND_NO_RESUMED;
3144 return null_ptid;
3145 }
0d62e5e8 3146
0bfdf32f 3147 event_child = get_thread_lwp (current_thread);
0d62e5e8 3148
fa96cb38
PA
3149 /* linux_wait_for_event only returns an exit status for the last
3150 child of a process. Report it. */
3151 if (WIFEXITED (w) || WIFSIGNALED (w))
da6d8c04 3152 {
fa96cb38 3153 if (WIFEXITED (w))
0d62e5e8 3154 {
fa96cb38
PA
3155 ourstatus->kind = TARGET_WAITKIND_EXITED;
3156 ourstatus->value.integer = WEXITSTATUS (w);
bd99dc85 3157
fa96cb38 3158 if (debug_threads)
bd99dc85 3159 {
fa96cb38
PA
3160 debug_printf ("linux_wait_1 ret = %s, exited with "
3161 "retcode %d\n",
0bfdf32f 3162 target_pid_to_str (ptid_of (current_thread)),
fa96cb38
PA
3163 WEXITSTATUS (w));
3164 debug_exit ();
bd99dc85 3165 }
fa96cb38
PA
3166 }
3167 else
3168 {
3169 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
3170 ourstatus->value.sig = gdb_signal_from_host (WTERMSIG (w));
5b1c542e 3171
fa96cb38
PA
3172 if (debug_threads)
3173 {
3174 debug_printf ("linux_wait_1 ret = %s, terminated with "
3175 "signal %d\n",
0bfdf32f 3176 target_pid_to_str (ptid_of (current_thread)),
fa96cb38
PA
3177 WTERMSIG (w));
3178 debug_exit ();
3179 }
0d62e5e8 3180 }
fa96cb38 3181
65706a29
PA
3182 if (ourstatus->kind == TARGET_WAITKIND_EXITED)
3183 return filter_exit_event (event_child, ourstatus);
3184
0bfdf32f 3185 return ptid_of (current_thread);
da6d8c04
DJ
3186 }
3187
2d97cd35
AT
3188 /* If step-over executes a breakpoint instruction, in the case of a
3189 hardware single step it means a gdb/gdbserver breakpoint had been
3190 planted on top of a permanent breakpoint, in the case of a software
3191 single step it may just mean that gdbserver hit the reinsert breakpoint.
e7ad2f14 3192 The PC has been adjusted by save_stop_reason to point at
2d97cd35
AT
3193 the breakpoint address.
3194 So in the case of the hardware single step advance the PC manually
3195 past the breakpoint and in the case of software single step advance only
3196 if it's not the reinsert_breakpoint we are hitting.
3197 This avoids that a program would keep trapping a permanent breakpoint
3198 forever. */
8090aef2 3199 if (!ptid_equal (step_over_bkpt, null_ptid)
2d97cd35
AT
3200 && event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3201 && (event_child->stepping
3202 || !reinsert_breakpoint_inserted_here (event_child->stop_pc)))
8090aef2 3203 {
dd373349
AT
3204 int increment_pc = 0;
3205 int breakpoint_kind = 0;
3206 CORE_ADDR stop_pc = event_child->stop_pc;
3207
769ef81f
AT
3208 breakpoint_kind =
3209 the_target->breakpoint_kind_from_current_state (&stop_pc);
dd373349 3210 the_target->sw_breakpoint_from_kind (breakpoint_kind, &increment_pc);
8090aef2
PA
3211
3212 if (debug_threads)
3213 {
3214 debug_printf ("step-over for %s executed software breakpoint\n",
3215 target_pid_to_str (ptid_of (current_thread)));
3216 }
3217
3218 if (increment_pc != 0)
3219 {
3220 struct regcache *regcache
3221 = get_thread_regcache (current_thread, 1);
3222
3223 event_child->stop_pc += increment_pc;
3224 (*the_low_target.set_pc) (regcache, event_child->stop_pc);
3225
3226 if (!(*the_low_target.breakpoint_at) (event_child->stop_pc))
15c66dd6 3227 event_child->stop_reason = TARGET_STOPPED_BY_NO_REASON;
8090aef2
PA
3228 }
3229 }
3230
6bf5e0ba
PA
3231 /* If this event was not handled before, and is not a SIGTRAP, we
3232 report it. SIGILL and SIGSEGV are also treated as traps in case
3233 a breakpoint is inserted at the current PC. If this target does
3234 not support internal breakpoints at all, we also report the
3235 SIGTRAP without further processing; it's of no concern to us. */
3236 maybe_internal_trap
3237 = (supports_breakpoints ()
3238 && (WSTOPSIG (w) == SIGTRAP
3239 || ((WSTOPSIG (w) == SIGILL
3240 || WSTOPSIG (w) == SIGSEGV)
3241 && (*the_low_target.breakpoint_at) (event_child->stop_pc))));
3242
3243 if (maybe_internal_trap)
3244 {
3245 /* Handle anything that requires bookkeeping before deciding to
3246 report the event or continue waiting. */
3247
3248 /* First check if we can explain the SIGTRAP with an internal
3249 breakpoint, or if we should possibly report the event to GDB.
3250 Do this before anything that may remove or insert a
3251 breakpoint. */
3252 bp_explains_trap = breakpoint_inserted_here (event_child->stop_pc);
3253
3254 /* We have a SIGTRAP, possibly a step-over dance has just
3255 finished. If so, tweak the state machine accordingly,
3256 reinsert breakpoints and delete any reinsert (software
3257 single-step) breakpoints. */
3258 step_over_finished = finish_step_over (event_child);
3259
3260 /* Now invoke the callbacks of any internal breakpoints there. */
3261 check_breakpoints (event_child->stop_pc);
3262
219f2f23
PA
3263 /* Handle tracepoint data collecting. This may overflow the
3264 trace buffer, and cause a tracing stop, removing
3265 breakpoints. */
3266 trace_event = handle_tracepoints (event_child);
3267
6bf5e0ba
PA
3268 if (bp_explains_trap)
3269 {
6bf5e0ba 3270 if (debug_threads)
87ce2a04 3271 debug_printf ("Hit a gdbserver breakpoint.\n");
6bf5e0ba
PA
3272 }
3273 }
3274 else
3275 {
3276 /* We have some other signal, possibly a step-over dance was in
3277 progress, and it should be cancelled too. */
3278 step_over_finished = finish_step_over (event_child);
fa593d66
PA
3279 }
3280
3281 /* We have all the data we need. Either report the event to GDB, or
3282 resume threads and keep waiting for more. */
3283
3284 /* If we're collecting a fast tracepoint, finish the collection and
3285 move out of the jump pad before delivering a signal. See
3286 linux_stabilize_threads. */
3287
3288 if (WIFSTOPPED (w)
3289 && WSTOPSIG (w) != SIGTRAP
3290 && supports_fast_tracepoints ()
58b4daa5 3291 && agent_loaded_p ())
fa593d66
PA
3292 {
3293 if (debug_threads)
87ce2a04
DE
3294 debug_printf ("Got signal %d for LWP %ld. Check if we need "
3295 "to defer or adjust it.\n",
0bfdf32f 3296 WSTOPSIG (w), lwpid_of (current_thread));
fa593d66
PA
3297
3298 /* Allow debugging the jump pad itself. */
0bfdf32f 3299 if (current_thread->last_resume_kind != resume_step
fa593d66
PA
3300 && maybe_move_out_of_jump_pad (event_child, &w))
3301 {
3302 enqueue_one_deferred_signal (event_child, &w);
3303
3304 if (debug_threads)
87ce2a04 3305 debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n",
0bfdf32f 3306 WSTOPSIG (w), lwpid_of (current_thread));
fa593d66
PA
3307
3308 linux_resume_one_lwp (event_child, 0, 0, NULL);
582511be
PA
3309
3310 return ignore_event (ourstatus);
fa593d66
PA
3311 }
3312 }
219f2f23 3313
fa593d66
PA
3314 if (event_child->collecting_fast_tracepoint)
3315 {
3316 if (debug_threads)
87ce2a04
DE
3317 debug_printf ("LWP %ld was trying to move out of the jump pad (%d). "
3318 "Check if we're already there.\n",
0bfdf32f 3319 lwpid_of (current_thread),
87ce2a04 3320 event_child->collecting_fast_tracepoint);
fa593d66
PA
3321
3322 trace_event = 1;
3323
3324 event_child->collecting_fast_tracepoint
3325 = linux_fast_tracepoint_collecting (event_child, NULL);
3326
3327 if (event_child->collecting_fast_tracepoint != 1)
3328 {
3329 /* No longer need this breakpoint. */
3330 if (event_child->exit_jump_pad_bkpt != NULL)
3331 {
3332 if (debug_threads)
87ce2a04
DE
3333 debug_printf ("No longer need exit-jump-pad bkpt; removing it."
3334 "stopping all threads momentarily.\n");
fa593d66
PA
3335
3336 /* Other running threads could hit this breakpoint.
3337 We don't handle moribund locations like GDB does,
3338 instead we always pause all threads when removing
3339 breakpoints, so that any step-over or
3340 decr_pc_after_break adjustment is always taken
3341 care of while the breakpoint is still
3342 inserted. */
3343 stop_all_lwps (1, event_child);
fa593d66
PA
3344
3345 delete_breakpoint (event_child->exit_jump_pad_bkpt);
3346 event_child->exit_jump_pad_bkpt = NULL;
3347
3348 unstop_all_lwps (1, event_child);
3349
3350 gdb_assert (event_child->suspended >= 0);
3351 }
3352 }
3353
3354 if (event_child->collecting_fast_tracepoint == 0)
3355 {
3356 if (debug_threads)
87ce2a04
DE
3357 debug_printf ("fast tracepoint finished "
3358 "collecting successfully.\n");
fa593d66
PA
3359
3360 /* We may have a deferred signal to report. */
3361 if (dequeue_one_deferred_signal (event_child, &w))
3362 {
3363 if (debug_threads)
87ce2a04 3364 debug_printf ("dequeued one signal.\n");
fa593d66 3365 }
3c11dd79 3366 else
fa593d66 3367 {
3c11dd79 3368 if (debug_threads)
87ce2a04 3369 debug_printf ("no deferred signals.\n");
fa593d66
PA
3370
3371 if (stabilizing_threads)
3372 {
3373 ourstatus->kind = TARGET_WAITKIND_STOPPED;
a493e3e2 3374 ourstatus->value.sig = GDB_SIGNAL_0;
87ce2a04
DE
3375
3376 if (debug_threads)
3377 {
3378 debug_printf ("linux_wait_1 ret = %s, stopped "
3379 "while stabilizing threads\n",
0bfdf32f 3380 target_pid_to_str (ptid_of (current_thread)));
87ce2a04
DE
3381 debug_exit ();
3382 }
3383
0bfdf32f 3384 return ptid_of (current_thread);
fa593d66
PA
3385 }
3386 }
3387 }
6bf5e0ba
PA
3388 }
3389
e471f25b
PA
3390 /* Check whether GDB would be interested in this event. */
3391
82075af2
JS
3392 /* Check if GDB is interested in this syscall. */
3393 if (WIFSTOPPED (w)
3394 && WSTOPSIG (w) == SYSCALL_SIGTRAP
3395 && !gdb_catch_this_syscall_p (event_child))
3396 {
3397 if (debug_threads)
3398 {
3399 debug_printf ("Ignored syscall for LWP %ld.\n",
3400 lwpid_of (current_thread));
3401 }
3402
3403 linux_resume_one_lwp (event_child, event_child->stepping,
3404 0, NULL);
3405 return ignore_event (ourstatus);
3406 }
3407
e471f25b
PA
3408 /* If GDB is not interested in this signal, don't stop other
3409 threads, and don't report it to GDB. Just resume the inferior
3410 right away. We do this for threading-related signals as well as
3411 any that GDB specifically requested we ignore. But never ignore
3412 SIGSTOP if we sent it ourselves, and do not ignore signals when
3413 stepping - they may require special handling to skip the signal
c9587f88
AT
3414 handler. Also never ignore signals that could be caused by a
3415 breakpoint. */
e471f25b 3416 if (WIFSTOPPED (w)
0bfdf32f 3417 && current_thread->last_resume_kind != resume_step
e471f25b 3418 && (
1a981360 3419#if defined (USE_THREAD_DB) && !defined (__ANDROID__)
fe978cb0 3420 (current_process ()->priv->thread_db != NULL
e471f25b
PA
3421 && (WSTOPSIG (w) == __SIGRTMIN
3422 || WSTOPSIG (w) == __SIGRTMIN + 1))
3423 ||
3424#endif
2ea28649 3425 (pass_signals[gdb_signal_from_host (WSTOPSIG (w))]
e471f25b 3426 && !(WSTOPSIG (w) == SIGSTOP
c9587f88
AT
3427 && current_thread->last_resume_kind == resume_stop)
3428 && !linux_wstatus_maybe_breakpoint (w))))
e471f25b
PA
3429 {
3430 siginfo_t info, *info_p;
3431
3432 if (debug_threads)
87ce2a04 3433 debug_printf ("Ignored signal %d for LWP %ld.\n",
0bfdf32f 3434 WSTOPSIG (w), lwpid_of (current_thread));
e471f25b 3435
0bfdf32f 3436 if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread),
b8e1b30e 3437 (PTRACE_TYPE_ARG3) 0, &info) == 0)
e471f25b
PA
3438 info_p = &info;
3439 else
3440 info_p = NULL;
863d01bd
PA
3441
3442 if (step_over_finished)
3443 {
3444 /* We cancelled this thread's step-over above. We still
3445 need to unsuspend all other LWPs, and set them back
3446 running again while the signal handler runs. */
3447 unsuspend_all_lwps (event_child);
3448
3449 /* Enqueue the pending signal info so that proceed_all_lwps
3450 doesn't lose it. */
3451 enqueue_pending_signal (event_child, WSTOPSIG (w), info_p);
3452
3453 proceed_all_lwps ();
3454 }
3455 else
3456 {
3457 linux_resume_one_lwp (event_child, event_child->stepping,
3458 WSTOPSIG (w), info_p);
3459 }
582511be 3460 return ignore_event (ourstatus);
e471f25b
PA
3461 }
3462
c2d6af84
PA
3463 /* Note that all addresses are always "out of the step range" when
3464 there's no range to begin with. */
3465 in_step_range = lwp_in_step_range (event_child);
3466
3467 /* If GDB wanted this thread to single step, and the thread is out
3468 of the step range, we always want to report the SIGTRAP, and let
3469 GDB handle it. Watchpoints should always be reported. So should
3470 signals we can't explain. A SIGTRAP we can't explain could be a
3471 GDB breakpoint --- we may or not support Z0 breakpoints. If we
3472 do, we're be able to handle GDB breakpoints on top of internal
3473 breakpoints, by handling the internal breakpoint and still
3474 reporting the event to GDB. If we don't, we're out of luck, GDB
863d01bd
PA
3475 won't see the breakpoint hit. If we see a single-step event but
3476 the thread should be continuing, don't pass the trap to gdb.
3477 That indicates that we had previously finished a single-step but
3478 left the single-step pending -- see
3479 complete_ongoing_step_over. */
6bf5e0ba 3480 report_to_gdb = (!maybe_internal_trap
0bfdf32f 3481 || (current_thread->last_resume_kind == resume_step
c2d6af84 3482 && !in_step_range)
15c66dd6 3483 || event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
863d01bd
PA
3484 || (!in_step_range
3485 && !bp_explains_trap
3486 && !trace_event
3487 && !step_over_finished
3488 && !(current_thread->last_resume_kind == resume_continue
3489 && event_child->stop_reason == TARGET_STOPPED_BY_SINGLE_STEP))
9f3a5c85 3490 || (gdb_breakpoint_here (event_child->stop_pc)
d3ce09f5 3491 && gdb_condition_true_at_breakpoint (event_child->stop_pc)
de0d863e 3492 && gdb_no_commands_at_breakpoint (event_child->stop_pc))
00db26fa 3493 || event_child->waitstatus.kind != TARGET_WAITKIND_IGNORE);
d3ce09f5
SS
3494
3495 run_breakpoint_commands (event_child->stop_pc);
6bf5e0ba
PA
3496
3497 /* We found no reason GDB would want us to stop. We either hit one
3498 of our own breakpoints, or finished an internal step GDB
3499 shouldn't know about. */
3500 if (!report_to_gdb)
3501 {
3502 if (debug_threads)
3503 {
3504 if (bp_explains_trap)
87ce2a04 3505 debug_printf ("Hit a gdbserver breakpoint.\n");
6bf5e0ba 3506 if (step_over_finished)
87ce2a04 3507 debug_printf ("Step-over finished.\n");
219f2f23 3508 if (trace_event)
87ce2a04 3509 debug_printf ("Tracepoint event.\n");
c2d6af84 3510 if (lwp_in_step_range (event_child))
87ce2a04
DE
3511 debug_printf ("Range stepping pc 0x%s [0x%s, 0x%s).\n",
3512 paddress (event_child->stop_pc),
3513 paddress (event_child->step_range_start),
3514 paddress (event_child->step_range_end));
6bf5e0ba
PA
3515 }
3516
3517 /* We're not reporting this breakpoint to GDB, so apply the
3518 decr_pc_after_break adjustment to the inferior's regcache
3519 ourselves. */
3520
3521 if (the_low_target.set_pc != NULL)
3522 {
3523 struct regcache *regcache
0bfdf32f 3524 = get_thread_regcache (current_thread, 1);
6bf5e0ba
PA
3525 (*the_low_target.set_pc) (regcache, event_child->stop_pc);
3526 }
3527
7984d532
PA
3528 /* We may have finished stepping over a breakpoint. If so,
3529 we've stopped and suspended all LWPs momentarily except the
3530 stepping one. This is where we resume them all again. We're
3531 going to keep waiting, so use proceed, which handles stepping
3532 over the next breakpoint. */
6bf5e0ba 3533 if (debug_threads)
87ce2a04 3534 debug_printf ("proceeding all threads.\n");
7984d532
PA
3535
3536 if (step_over_finished)
3537 unsuspend_all_lwps (event_child);
3538
6bf5e0ba 3539 proceed_all_lwps ();
582511be 3540 return ignore_event (ourstatus);
6bf5e0ba
PA
3541 }
3542
3543 if (debug_threads)
3544 {
00db26fa 3545 if (event_child->waitstatus.kind != TARGET_WAITKIND_IGNORE)
ad071a30
PA
3546 {
3547 char *str;
3548
3549 str = target_waitstatus_to_string (&event_child->waitstatus);
3550 debug_printf ("LWP %ld: extended event with waitstatus %s\n",
3551 lwpid_of (get_lwp_thread (event_child)), str);
3552 xfree (str);
3553 }
0bfdf32f 3554 if (current_thread->last_resume_kind == resume_step)
c2d6af84
PA
3555 {
3556 if (event_child->step_range_start == event_child->step_range_end)
87ce2a04 3557 debug_printf ("GDB wanted to single-step, reporting event.\n");
c2d6af84 3558 else if (!lwp_in_step_range (event_child))
87ce2a04 3559 debug_printf ("Out of step range, reporting event.\n");
c2d6af84 3560 }
15c66dd6 3561 if (event_child->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
87ce2a04 3562 debug_printf ("Stopped by watchpoint.\n");
582511be 3563 else if (gdb_breakpoint_here (event_child->stop_pc))
87ce2a04 3564 debug_printf ("Stopped by GDB breakpoint.\n");
6bf5e0ba 3565 if (debug_threads)
87ce2a04 3566 debug_printf ("Hit a non-gdbserver trap event.\n");
6bf5e0ba
PA
3567 }
3568
3569 /* Alright, we're going to report a stop. */
3570
582511be 3571 if (!stabilizing_threads)
6bf5e0ba
PA
3572 {
3573 /* In all-stop, stop all threads. */
582511be
PA
3574 if (!non_stop)
3575 stop_all_lwps (0, NULL);
6bf5e0ba
PA
3576
3577 /* If we're not waiting for a specific LWP, choose an event LWP
3578 from among those that have had events. Giving equal priority
3579 to all LWPs that have had events helps prevent
3580 starvation. */
3581 if (ptid_equal (ptid, minus_one_ptid))
3582 {
3583 event_child->status_pending_p = 1;
3584 event_child->status_pending = w;
3585
3586 select_event_lwp (&event_child);
3587
0bfdf32f
GB
3588 /* current_thread and event_child must stay in sync. */
3589 current_thread = get_lwp_thread (event_child);
ee1e2d4f 3590
6bf5e0ba
PA
3591 event_child->status_pending_p = 0;
3592 w = event_child->status_pending;
3593 }
3594
c03e6ccc 3595 if (step_over_finished)
582511be
PA
3596 {
3597 if (!non_stop)
3598 {
3599 /* If we were doing a step-over, all other threads but
3600 the stepping one had been paused in start_step_over,
3601 with their suspend counts incremented. We don't want
3602 to do a full unstop/unpause, because we're in
3603 all-stop mode (so we want threads stopped), but we
3604 still need to unsuspend the other threads, to
3605 decrement their `suspended' count back. */
3606 unsuspend_all_lwps (event_child);
3607 }
3608 else
3609 {
3610 /* If we just finished a step-over, then all threads had
3611 been momentarily paused. In all-stop, that's fine,
3612 we want threads stopped by now anyway. In non-stop,
3613 we need to re-resume threads that GDB wanted to be
3614 running. */
3615 unstop_all_lwps (1, event_child);
3616 }
3617 }
c03e6ccc 3618
fa593d66 3619 /* Stabilize threads (move out of jump pads). */
582511be
PA
3620 if (!non_stop)
3621 stabilize_threads ();
6bf5e0ba
PA
3622 }
3623 else
3624 {
3625 /* If we just finished a step-over, then all threads had been
3626 momentarily paused. In all-stop, that's fine, we want
3627 threads stopped by now anyway. In non-stop, we need to
3628 re-resume threads that GDB wanted to be running. */
3629 if (step_over_finished)
7984d532 3630 unstop_all_lwps (1, event_child);
6bf5e0ba
PA
3631 }
3632
00db26fa 3633 if (event_child->waitstatus.kind != TARGET_WAITKIND_IGNORE)
de0d863e 3634 {
00db26fa
PA
3635 /* If the reported event is an exit, fork, vfork or exec, let
3636 GDB know. */
3637 *ourstatus = event_child->waitstatus;
de0d863e
DB
3638 /* Clear the event lwp's waitstatus since we handled it already. */
3639 event_child->waitstatus.kind = TARGET_WAITKIND_IGNORE;
3640 }
3641 else
3642 ourstatus->kind = TARGET_WAITKIND_STOPPED;
5b1c542e 3643
582511be 3644 /* Now that we've selected our final event LWP, un-adjust its PC if
3e572f71
PA
3645 it was a software breakpoint, and the client doesn't know we can
3646 adjust the breakpoint ourselves. */
3647 if (event_child->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT
3648 && !swbreak_feature)
582511be
PA
3649 {
3650 int decr_pc = the_low_target.decr_pc_after_break;
3651
3652 if (decr_pc != 0)
3653 {
3654 struct regcache *regcache
3655 = get_thread_regcache (current_thread, 1);
3656 (*the_low_target.set_pc) (regcache, event_child->stop_pc + decr_pc);
3657 }
3658 }
3659
82075af2
JS
3660 if (WSTOPSIG (w) == SYSCALL_SIGTRAP)
3661 {
3662 int sysret;
3663
3664 get_syscall_trapinfo (event_child,
3665 &ourstatus->value.syscall_number, &sysret);
3666 ourstatus->kind = event_child->syscall_state;
3667 }
3668 else if (current_thread->last_resume_kind == resume_stop
3669 && WSTOPSIG (w) == SIGSTOP)
bd99dc85
PA
3670 {
3671 /* A thread that has been requested to stop by GDB with vCont;t,
3672 and it stopped cleanly, so report as SIG0. The use of
3673 SIGSTOP is an implementation detail. */
a493e3e2 3674 ourstatus->value.sig = GDB_SIGNAL_0;
bd99dc85 3675 }
0bfdf32f 3676 else if (current_thread->last_resume_kind == resume_stop
8336d594 3677 && WSTOPSIG (w) != SIGSTOP)
bd99dc85
PA
3678 {
3679 /* A thread that has been requested to stop by GDB with vCont;t,
d50171e4 3680 but, it stopped for other reasons. */
2ea28649 3681 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
bd99dc85 3682 }
de0d863e 3683 else if (ourstatus->kind == TARGET_WAITKIND_STOPPED)
bd99dc85 3684 {
2ea28649 3685 ourstatus->value.sig = gdb_signal_from_host (WSTOPSIG (w));
bd99dc85
PA
3686 }
3687
d50171e4
PA
3688 gdb_assert (ptid_equal (step_over_bkpt, null_ptid));
3689
bd99dc85 3690 if (debug_threads)
87ce2a04
DE
3691 {
3692 debug_printf ("linux_wait_1 ret = %s, %d, %d\n",
0bfdf32f 3693 target_pid_to_str (ptid_of (current_thread)),
87ce2a04
DE
3694 ourstatus->kind, ourstatus->value.sig);
3695 debug_exit ();
3696 }
bd99dc85 3697
65706a29
PA
3698 if (ourstatus->kind == TARGET_WAITKIND_EXITED)
3699 return filter_exit_event (event_child, ourstatus);
3700
0bfdf32f 3701 return ptid_of (current_thread);
bd99dc85
PA
3702}
3703
3704/* Get rid of any pending event in the pipe. */
3705static void
3706async_file_flush (void)
3707{
3708 int ret;
3709 char buf;
3710
3711 do
3712 ret = read (linux_event_pipe[0], &buf, 1);
3713 while (ret >= 0 || (ret == -1 && errno == EINTR));
3714}
3715
3716/* Put something in the pipe, so the event loop wakes up. */
3717static void
3718async_file_mark (void)
3719{
3720 int ret;
3721
3722 async_file_flush ();
3723
3724 do
3725 ret = write (linux_event_pipe[1], "+", 1);
3726 while (ret == 0 || (ret == -1 && errno == EINTR));
3727
3728 /* Ignore EAGAIN. If the pipe is full, the event loop will already
3729 be awakened anyway. */
3730}
3731
95954743
PA
3732static ptid_t
3733linux_wait (ptid_t ptid,
3734 struct target_waitstatus *ourstatus, int target_options)
bd99dc85 3735{
95954743 3736 ptid_t event_ptid;
bd99dc85 3737
bd99dc85
PA
3738 /* Flush the async file first. */
3739 if (target_is_async_p ())
3740 async_file_flush ();
3741
582511be
PA
3742 do
3743 {
3744 event_ptid = linux_wait_1 (ptid, ourstatus, target_options);
3745 }
3746 while ((target_options & TARGET_WNOHANG) == 0
3747 && ptid_equal (event_ptid, null_ptid)
3748 && ourstatus->kind == TARGET_WAITKIND_IGNORE);
bd99dc85
PA
3749
3750 /* If at least one stop was reported, there may be more. A single
3751 SIGCHLD can signal more than one child stop. */
3752 if (target_is_async_p ()
3753 && (target_options & TARGET_WNOHANG) != 0
95954743 3754 && !ptid_equal (event_ptid, null_ptid))
bd99dc85
PA
3755 async_file_mark ();
3756
3757 return event_ptid;
da6d8c04
DJ
3758}
3759
c5f62d5f 3760/* Send a signal to an LWP. */
fd500816
DJ
3761
3762static int
a1928bad 3763kill_lwp (unsigned long lwpid, int signo)
fd500816 3764{
4a6ed09b 3765 int ret;
fd500816 3766
4a6ed09b
PA
3767 errno = 0;
3768 ret = syscall (__NR_tkill, lwpid, signo);
3769 if (errno == ENOSYS)
3770 {
3771 /* If tkill fails, then we are not using nptl threads, a
3772 configuration we no longer support. */
3773 perror_with_name (("tkill"));
3774 }
3775 return ret;
fd500816
DJ
3776}
3777
964e4306
PA
3778void
3779linux_stop_lwp (struct lwp_info *lwp)
3780{
3781 send_sigstop (lwp);
3782}
3783
0d62e5e8 3784static void
02fc4de7 3785send_sigstop (struct lwp_info *lwp)
0d62e5e8 3786{
bd99dc85 3787 int pid;
0d62e5e8 3788
d86d4aaf 3789 pid = lwpid_of (get_lwp_thread (lwp));
bd99dc85 3790
0d62e5e8
DJ
3791 /* If we already have a pending stop signal for this process, don't
3792 send another. */
54a0b537 3793 if (lwp->stop_expected)
0d62e5e8 3794 {
ae13219e 3795 if (debug_threads)
87ce2a04 3796 debug_printf ("Have pending sigstop for lwp %d\n", pid);
ae13219e 3797
0d62e5e8
DJ
3798 return;
3799 }
3800
3801 if (debug_threads)
87ce2a04 3802 debug_printf ("Sending sigstop to lwp %d\n", pid);
0d62e5e8 3803
d50171e4 3804 lwp->stop_expected = 1;
bd99dc85 3805 kill_lwp (pid, SIGSTOP);
0d62e5e8
DJ
3806}
3807
7984d532
PA
3808static int
3809send_sigstop_callback (struct inferior_list_entry *entry, void *except)
02fc4de7 3810{
d86d4aaf
DE
3811 struct thread_info *thread = (struct thread_info *) entry;
3812 struct lwp_info *lwp = get_thread_lwp (thread);
02fc4de7 3813
7984d532
PA
3814 /* Ignore EXCEPT. */
3815 if (lwp == except)
3816 return 0;
3817
02fc4de7 3818 if (lwp->stopped)
7984d532 3819 return 0;
02fc4de7
PA
3820
3821 send_sigstop (lwp);
7984d532
PA
3822 return 0;
3823}
3824
3825/* Increment the suspend count of an LWP, and stop it, if not stopped
3826 yet. */
3827static int
3828suspend_and_send_sigstop_callback (struct inferior_list_entry *entry,
3829 void *except)
3830{
d86d4aaf
DE
3831 struct thread_info *thread = (struct thread_info *) entry;
3832 struct lwp_info *lwp = get_thread_lwp (thread);
7984d532
PA
3833
3834 /* Ignore EXCEPT. */
3835 if (lwp == except)
3836 return 0;
3837
863d01bd 3838 lwp_suspended_inc (lwp);
7984d532
PA
3839
3840 return send_sigstop_callback (entry, except);
02fc4de7
PA
3841}
3842
95954743
PA
3843static void
3844mark_lwp_dead (struct lwp_info *lwp, int wstat)
3845{
95954743
PA
3846 /* Store the exit status for later. */
3847 lwp->status_pending_p = 1;
3848 lwp->status_pending = wstat;
3849
00db26fa
PA
3850 /* Store in waitstatus as well, as there's nothing else to process
3851 for this event. */
3852 if (WIFEXITED (wstat))
3853 {
3854 lwp->waitstatus.kind = TARGET_WAITKIND_EXITED;
3855 lwp->waitstatus.value.integer = WEXITSTATUS (wstat);
3856 }
3857 else if (WIFSIGNALED (wstat))
3858 {
3859 lwp->waitstatus.kind = TARGET_WAITKIND_SIGNALLED;
3860 lwp->waitstatus.value.sig = gdb_signal_from_host (WTERMSIG (wstat));
3861 }
3862
95954743
PA
3863 /* Prevent trying to stop it. */
3864 lwp->stopped = 1;
3865
3866 /* No further stops are expected from a dead lwp. */
3867 lwp->stop_expected = 0;
3868}
3869
00db26fa
PA
3870/* Return true if LWP has exited already, and has a pending exit event
3871 to report to GDB. */
3872
3873static int
3874lwp_is_marked_dead (struct lwp_info *lwp)
3875{
3876 return (lwp->status_pending_p
3877 && (WIFEXITED (lwp->status_pending)
3878 || WIFSIGNALED (lwp->status_pending)));
3879}
3880
fa96cb38
PA
3881/* Wait for all children to stop for the SIGSTOPs we just queued. */
3882
0d62e5e8 3883static void
fa96cb38 3884wait_for_sigstop (void)
0d62e5e8 3885{
0bfdf32f 3886 struct thread_info *saved_thread;
95954743 3887 ptid_t saved_tid;
fa96cb38
PA
3888 int wstat;
3889 int ret;
0d62e5e8 3890
0bfdf32f
GB
3891 saved_thread = current_thread;
3892 if (saved_thread != NULL)
3893 saved_tid = saved_thread->entry.id;
bd99dc85 3894 else
95954743 3895 saved_tid = null_ptid; /* avoid bogus unused warning */
bd99dc85 3896
d50171e4 3897 if (debug_threads)
fa96cb38 3898 debug_printf ("wait_for_sigstop: pulling events\n");
d50171e4 3899
fa96cb38
PA
3900 /* Passing NULL_PTID as filter indicates we want all events to be
3901 left pending. Eventually this returns when there are no
3902 unwaited-for children left. */
3903 ret = linux_wait_for_event_filtered (minus_one_ptid, null_ptid,
3904 &wstat, __WALL);
3905 gdb_assert (ret == -1);
0d62e5e8 3906
0bfdf32f
GB
3907 if (saved_thread == NULL || linux_thread_alive (saved_tid))
3908 current_thread = saved_thread;
0d62e5e8
DJ
3909 else
3910 {
3911 if (debug_threads)
87ce2a04 3912 debug_printf ("Previously current thread died.\n");
0d62e5e8 3913
f0db101d
PA
3914 /* We can't change the current inferior behind GDB's back,
3915 otherwise, a subsequent command may apply to the wrong
3916 process. */
3917 current_thread = NULL;
0d62e5e8
DJ
3918 }
3919}
3920
fa593d66
PA
3921/* Returns true if LWP ENTRY is stopped in a jump pad, and we can't
3922 move it out, because we need to report the stop event to GDB. For
3923 example, if the user puts a breakpoint in the jump pad, it's
3924 because she wants to debug it. */
3925
3926static int
3927stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data)
3928{
d86d4aaf
DE
3929 struct thread_info *thread = (struct thread_info *) entry;
3930 struct lwp_info *lwp = get_thread_lwp (thread);
fa593d66 3931
863d01bd
PA
3932 if (lwp->suspended != 0)
3933 {
3934 internal_error (__FILE__, __LINE__,
3935 "LWP %ld is suspended, suspended=%d\n",
3936 lwpid_of (thread), lwp->suspended);
3937 }
fa593d66
PA
3938 gdb_assert (lwp->stopped);
3939
3940 /* Allow debugging the jump pad, gdb_collect, etc.. */
3941 return (supports_fast_tracepoints ()
58b4daa5 3942 && agent_loaded_p ()
fa593d66 3943 && (gdb_breakpoint_here (lwp->stop_pc)
15c66dd6 3944 || lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT
fa593d66
PA
3945 || thread->last_resume_kind == resume_step)
3946 && linux_fast_tracepoint_collecting (lwp, NULL));
3947}
3948
3949static void
3950move_out_of_jump_pad_callback (struct inferior_list_entry *entry)
3951{
d86d4aaf 3952 struct thread_info *thread = (struct thread_info *) entry;
f0ce0d3a 3953 struct thread_info *saved_thread;
d86d4aaf 3954 struct lwp_info *lwp = get_thread_lwp (thread);
fa593d66
PA
3955 int *wstat;
3956
863d01bd
PA
3957 if (lwp->suspended != 0)
3958 {
3959 internal_error (__FILE__, __LINE__,
3960 "LWP %ld is suspended, suspended=%d\n",
3961 lwpid_of (thread), lwp->suspended);
3962 }
fa593d66
PA
3963 gdb_assert (lwp->stopped);
3964
f0ce0d3a
PA
3965 /* For gdb_breakpoint_here. */
3966 saved_thread = current_thread;
3967 current_thread = thread;
3968
fa593d66
PA
3969 wstat = lwp->status_pending_p ? &lwp->status_pending : NULL;
3970
3971 /* Allow debugging the jump pad, gdb_collect, etc. */
3972 if (!gdb_breakpoint_here (lwp->stop_pc)
15c66dd6 3973 && lwp->stop_reason != TARGET_STOPPED_BY_WATCHPOINT
fa593d66
PA
3974 && thread->last_resume_kind != resume_step
3975 && maybe_move_out_of_jump_pad (lwp, wstat))
3976 {
3977 if (debug_threads)
87ce2a04 3978 debug_printf ("LWP %ld needs stabilizing (in jump pad)\n",
d86d4aaf 3979 lwpid_of (thread));
fa593d66
PA
3980
3981 if (wstat)
3982 {
3983 lwp->status_pending_p = 0;
3984 enqueue_one_deferred_signal (lwp, wstat);
3985
3986 if (debug_threads)
87ce2a04
DE
3987 debug_printf ("Signal %d for LWP %ld deferred "
3988 "(in jump pad)\n",
d86d4aaf 3989 WSTOPSIG (*wstat), lwpid_of (thread));
fa593d66
PA
3990 }
3991
3992 linux_resume_one_lwp (lwp, 0, 0, NULL);
3993 }
3994 else
863d01bd 3995 lwp_suspended_inc (lwp);
f0ce0d3a
PA
3996
3997 current_thread = saved_thread;
fa593d66
PA
3998}
3999
4000static int
4001lwp_running (struct inferior_list_entry *entry, void *data)
4002{
d86d4aaf
DE
4003 struct thread_info *thread = (struct thread_info *) entry;
4004 struct lwp_info *lwp = get_thread_lwp (thread);
fa593d66 4005
00db26fa 4006 if (lwp_is_marked_dead (lwp))
fa593d66
PA
4007 return 0;
4008 if (lwp->stopped)
4009 return 0;
4010 return 1;
4011}
4012
7984d532
PA
4013/* Stop all lwps that aren't stopped yet, except EXCEPT, if not NULL.
4014 If SUSPEND, then also increase the suspend count of every LWP,
4015 except EXCEPT. */
4016
0d62e5e8 4017static void
7984d532 4018stop_all_lwps (int suspend, struct lwp_info *except)
0d62e5e8 4019{
bde24c0a
PA
4020 /* Should not be called recursively. */
4021 gdb_assert (stopping_threads == NOT_STOPPING_THREADS);
4022
87ce2a04
DE
4023 if (debug_threads)
4024 {
4025 debug_enter ();
4026 debug_printf ("stop_all_lwps (%s, except=%s)\n",
4027 suspend ? "stop-and-suspend" : "stop",
4028 except != NULL
d86d4aaf 4029 ? target_pid_to_str (ptid_of (get_lwp_thread (except)))
87ce2a04
DE
4030 : "none");
4031 }
4032
bde24c0a
PA
4033 stopping_threads = (suspend
4034 ? STOPPING_AND_SUSPENDING_THREADS
4035 : STOPPING_THREADS);
7984d532
PA
4036
4037 if (suspend)
d86d4aaf 4038 find_inferior (&all_threads, suspend_and_send_sigstop_callback, except);
7984d532 4039 else
d86d4aaf 4040 find_inferior (&all_threads, send_sigstop_callback, except);
fa96cb38 4041 wait_for_sigstop ();
bde24c0a 4042 stopping_threads = NOT_STOPPING_THREADS;
87ce2a04
DE
4043
4044 if (debug_threads)
4045 {
4046 debug_printf ("stop_all_lwps done, setting stopping_threads "
4047 "back to !stopping\n");
4048 debug_exit ();
4049 }
0d62e5e8
DJ
4050}
4051
863d01bd
PA
4052/* Enqueue one signal in the chain of signals which need to be
4053 delivered to this process on next resume. */
4054
4055static void
4056enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info)
4057{
8d749320 4058 struct pending_signals *p_sig = XNEW (struct pending_signals);
863d01bd 4059
863d01bd
PA
4060 p_sig->prev = lwp->pending_signals;
4061 p_sig->signal = signal;
4062 if (info == NULL)
4063 memset (&p_sig->info, 0, sizeof (siginfo_t));
4064 else
4065 memcpy (&p_sig->info, info, sizeof (siginfo_t));
4066 lwp->pending_signals = p_sig;
4067}
4068
fa5308bd
AT
4069/* Install breakpoints for software single stepping. */
4070
4071static void
4072install_software_single_step_breakpoints (struct lwp_info *lwp)
4073{
4074 int i;
4075 CORE_ADDR pc;
4076 struct regcache *regcache = get_thread_regcache (current_thread, 1);
4077 VEC (CORE_ADDR) *next_pcs = NULL;
4078 struct cleanup *old_chain = make_cleanup (VEC_cleanup (CORE_ADDR), &next_pcs);
4079
4d18591b 4080 next_pcs = (*the_low_target.get_next_pcs) (regcache);
fa5308bd
AT
4081
4082 for (i = 0; VEC_iterate (CORE_ADDR, next_pcs, i, pc); ++i)
4083 set_reinsert_breakpoint (pc);
4084
4085 do_cleanups (old_chain);
4086}
4087
7fe5e27e
AT
4088/* Single step via hardware or software single step.
4089 Return 1 if hardware single stepping, 0 if software single stepping
4090 or can't single step. */
4091
4092static int
4093single_step (struct lwp_info* lwp)
4094{
4095 int step = 0;
4096
4097 if (can_hardware_single_step ())
4098 {
4099 step = 1;
4100 }
4101 else if (can_software_single_step ())
4102 {
4103 install_software_single_step_breakpoints (lwp);
4104 step = 0;
4105 }
4106 else
4107 {
4108 if (debug_threads)
4109 debug_printf ("stepping is not implemented on this target");
4110 }
4111
4112 return step;
4113}
4114
35ac8b3e 4115/* The signal can be delivered to the inferior if we are not trying to
5b061e98
YQ
4116 finish a fast tracepoint collect. Since signal can be delivered in
4117 the step-over, the program may go to signal handler and trap again
4118 after return from the signal handler. We can live with the spurious
4119 double traps. */
35ac8b3e
YQ
4120
4121static int
4122lwp_signal_can_be_delivered (struct lwp_info *lwp)
4123{
484b3c32 4124 return !lwp->collecting_fast_tracepoint;
35ac8b3e
YQ
4125}
4126
23f238d3
PA
4127/* Resume execution of LWP. If STEP is nonzero, single-step it. If
4128 SIGNAL is nonzero, give it that signal. */
da6d8c04 4129
ce3a066d 4130static void
23f238d3
PA
4131linux_resume_one_lwp_throw (struct lwp_info *lwp,
4132 int step, int signal, siginfo_t *info)
da6d8c04 4133{
d86d4aaf 4134 struct thread_info *thread = get_lwp_thread (lwp);
0bfdf32f 4135 struct thread_info *saved_thread;
fa593d66 4136 int fast_tp_collecting;
82075af2 4137 int ptrace_request;
c06cbd92
YQ
4138 struct process_info *proc = get_thread_process (thread);
4139
4140 /* Note that target description may not be initialised
4141 (proc->tdesc == NULL) at this point because the program hasn't
4142 stopped at the first instruction yet. It means GDBserver skips
4143 the extra traps from the wrapper program (see option --wrapper).
4144 Code in this function that requires register access should be
4145 guarded by proc->tdesc == NULL or something else. */
0d62e5e8 4146
54a0b537 4147 if (lwp->stopped == 0)
0d62e5e8
DJ
4148 return;
4149
65706a29
PA
4150 gdb_assert (lwp->waitstatus.kind == TARGET_WAITKIND_IGNORE);
4151
fa593d66
PA
4152 fast_tp_collecting = lwp->collecting_fast_tracepoint;
4153
4154 gdb_assert (!stabilizing_threads || fast_tp_collecting);
4155
219f2f23
PA
4156 /* Cancel actions that rely on GDB not changing the PC (e.g., the
4157 user used the "jump" command, or "set $pc = foo"). */
c06cbd92 4158 if (thread->while_stepping != NULL && lwp->stop_pc != get_pc (lwp))
219f2f23
PA
4159 {
4160 /* Collecting 'while-stepping' actions doesn't make sense
4161 anymore. */
d86d4aaf 4162 release_while_stepping_state_list (thread);
219f2f23
PA
4163 }
4164
0d62e5e8 4165 /* If we have pending signals or status, and a new signal, enqueue the
35ac8b3e
YQ
4166 signal. Also enqueue the signal if it can't be delivered to the
4167 inferior right now. */
0d62e5e8 4168 if (signal != 0
fa593d66
PA
4169 && (lwp->status_pending_p
4170 || lwp->pending_signals != NULL
35ac8b3e 4171 || !lwp_signal_can_be_delivered (lwp)))
94610ec4
YQ
4172 {
4173 enqueue_pending_signal (lwp, signal, info);
4174
4175 /* Postpone any pending signal. It was enqueued above. */
4176 signal = 0;
4177 }
0d62e5e8 4178
d50171e4
PA
4179 if (lwp->status_pending_p)
4180 {
4181 if (debug_threads)
94610ec4 4182 debug_printf ("Not resuming lwp %ld (%s, stop %s);"
87ce2a04 4183 " has pending status\n",
94610ec4 4184 lwpid_of (thread), step ? "step" : "continue",
87ce2a04 4185 lwp->stop_expected ? "expected" : "not expected");
d50171e4
PA
4186 return;
4187 }
0d62e5e8 4188
0bfdf32f
GB
4189 saved_thread = current_thread;
4190 current_thread = thread;
0d62e5e8 4191
0d62e5e8
DJ
4192 /* This bit needs some thinking about. If we get a signal that
4193 we must report while a single-step reinsert is still pending,
4194 we often end up resuming the thread. It might be better to
4195 (ew) allow a stack of pending events; then we could be sure that
4196 the reinsert happened right away and not lose any signals.
4197
4198 Making this stack would also shrink the window in which breakpoints are
54a0b537 4199 uninserted (see comment in linux_wait_for_lwp) but not enough for
0d62e5e8
DJ
4200 complete correctness, so it won't solve that problem. It may be
4201 worthwhile just to solve this one, however. */
54a0b537 4202 if (lwp->bp_reinsert != 0)
0d62e5e8
DJ
4203 {
4204 if (debug_threads)
87ce2a04
DE
4205 debug_printf (" pending reinsert at 0x%s\n",
4206 paddress (lwp->bp_reinsert));
d50171e4 4207
85e00e85 4208 if (can_hardware_single_step ())
d50171e4 4209 {
fa593d66
PA
4210 if (fast_tp_collecting == 0)
4211 {
4212 if (step == 0)
4213 fprintf (stderr, "BAD - reinserting but not stepping.\n");
4214 if (lwp->suspended)
4215 fprintf (stderr, "BAD - reinserting and suspended(%d).\n",
4216 lwp->suspended);
4217 }
d50171e4
PA
4218
4219 step = 1;
4220 }
0d62e5e8
DJ
4221 }
4222
fa593d66
PA
4223 if (fast_tp_collecting == 1)
4224 {
4225 if (debug_threads)
87ce2a04
DE
4226 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
4227 " (exit-jump-pad-bkpt)\n",
d86d4aaf 4228 lwpid_of (thread));
fa593d66
PA
4229 }
4230 else if (fast_tp_collecting == 2)
4231 {
4232 if (debug_threads)
87ce2a04
DE
4233 debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad"
4234 " single-stepping\n",
d86d4aaf 4235 lwpid_of (thread));
fa593d66
PA
4236
4237 if (can_hardware_single_step ())
4238 step = 1;
4239 else
38e08fca
GB
4240 {
4241 internal_error (__FILE__, __LINE__,
4242 "moving out of jump pad single-stepping"
4243 " not implemented on this target");
4244 }
fa593d66
PA
4245 }
4246
219f2f23
PA
4247 /* If we have while-stepping actions in this thread set it stepping.
4248 If we have a signal to deliver, it may or may not be set to
4249 SIG_IGN, we don't know. Assume so, and allow collecting
4250 while-stepping into a signal handler. A possible smart thing to
4251 do would be to set an internal breakpoint at the signal return
4252 address, continue, and carry on catching this while-stepping
4253 action only when that breakpoint is hit. A future
4254 enhancement. */
7fe5e27e 4255 if (thread->while_stepping != NULL)
219f2f23
PA
4256 {
4257 if (debug_threads)
87ce2a04 4258 debug_printf ("lwp %ld has a while-stepping action -> forcing step.\n",
d86d4aaf 4259 lwpid_of (thread));
7fe5e27e
AT
4260
4261 step = single_step (lwp);
219f2f23
PA
4262 }
4263
c06cbd92 4264 if (proc->tdesc != NULL && the_low_target.get_pc != NULL)
0d62e5e8 4265 {
0bfdf32f 4266 struct regcache *regcache = get_thread_regcache (current_thread, 1);
582511be
PA
4267
4268 lwp->stop_pc = (*the_low_target.get_pc) (regcache);
4269
4270 if (debug_threads)
4271 {
4272 debug_printf (" %s from pc 0x%lx\n", step ? "step" : "continue",
4273 (long) lwp->stop_pc);
4274 }
0d62e5e8
DJ
4275 }
4276
35ac8b3e
YQ
4277 /* If we have pending signals, consume one if it can be delivered to
4278 the inferior. */
4279 if (lwp->pending_signals != NULL && lwp_signal_can_be_delivered (lwp))
0d62e5e8
DJ
4280 {
4281 struct pending_signals **p_sig;
4282
54a0b537 4283 p_sig = &lwp->pending_signals;
0d62e5e8
DJ
4284 while ((*p_sig)->prev != NULL)
4285 p_sig = &(*p_sig)->prev;
4286
4287 signal = (*p_sig)->signal;
32ca6d61 4288 if ((*p_sig)->info.si_signo != 0)
d86d4aaf 4289 ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
56f7af9c 4290 &(*p_sig)->info);
32ca6d61 4291
0d62e5e8
DJ
4292 free (*p_sig);
4293 *p_sig = NULL;
4294 }
4295
94610ec4
YQ
4296 if (debug_threads)
4297 debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n",
4298 lwpid_of (thread), step ? "step" : "continue", signal,
4299 lwp->stop_expected ? "expected" : "not expected");
4300
aa5ca48f
DE
4301 if (the_low_target.prepare_to_resume != NULL)
4302 the_low_target.prepare_to_resume (lwp);
4303
d86d4aaf 4304 regcache_invalidate_thread (thread);
da6d8c04 4305 errno = 0;
54a0b537 4306 lwp->stepping = step;
82075af2
JS
4307 if (step)
4308 ptrace_request = PTRACE_SINGLESTEP;
4309 else if (gdb_catching_syscalls_p (lwp))
4310 ptrace_request = PTRACE_SYSCALL;
4311 else
4312 ptrace_request = PTRACE_CONT;
4313 ptrace (ptrace_request,
4314 lwpid_of (thread),
b8e1b30e 4315 (PTRACE_TYPE_ARG3) 0,
14ce3065
DE
4316 /* Coerce to a uintptr_t first to avoid potential gcc warning
4317 of coercing an 8 byte integer to a 4 byte pointer. */
b8e1b30e 4318 (PTRACE_TYPE_ARG4) (uintptr_t) signal);
0d62e5e8 4319
0bfdf32f 4320 current_thread = saved_thread;
da6d8c04 4321 if (errno)
23f238d3
PA
4322 perror_with_name ("resuming thread");
4323
4324 /* Successfully resumed. Clear state that no longer makes sense,
4325 and mark the LWP as running. Must not do this before resuming
4326 otherwise if that fails other code will be confused. E.g., we'd
4327 later try to stop the LWP and hang forever waiting for a stop
4328 status. Note that we must not throw after this is cleared,
4329 otherwise handle_zombie_lwp_error would get confused. */
4330 lwp->stopped = 0;
4331 lwp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
4332}
4333
4334/* Called when we try to resume a stopped LWP and that errors out. If
4335 the LWP is no longer in ptrace-stopped state (meaning it's zombie,
4336 or about to become), discard the error, clear any pending status
4337 the LWP may have, and return true (we'll collect the exit status
4338 soon enough). Otherwise, return false. */
4339
4340static int
4341check_ptrace_stopped_lwp_gone (struct lwp_info *lp)
4342{
4343 struct thread_info *thread = get_lwp_thread (lp);
4344
4345 /* If we get an error after resuming the LWP successfully, we'd
4346 confuse !T state for the LWP being gone. */
4347 gdb_assert (lp->stopped);
4348
4349 /* We can't just check whether the LWP is in 'Z (Zombie)' state,
4350 because even if ptrace failed with ESRCH, the tracee may be "not
4351 yet fully dead", but already refusing ptrace requests. In that
4352 case the tracee has 'R (Running)' state for a little bit
4353 (observed in Linux 3.18). See also the note on ESRCH in the
4354 ptrace(2) man page. Instead, check whether the LWP has any state
4355 other than ptrace-stopped. */
4356
4357 /* Don't assume anything if /proc/PID/status can't be read. */
4358 if (linux_proc_pid_is_trace_stopped_nowarn (lwpid_of (thread)) == 0)
3221518c 4359 {
23f238d3
PA
4360 lp->stop_reason = TARGET_STOPPED_BY_NO_REASON;
4361 lp->status_pending_p = 0;
4362 return 1;
4363 }
4364 return 0;
4365}
4366
4367/* Like linux_resume_one_lwp_throw, but no error is thrown if the LWP
4368 disappears while we try to resume it. */
3221518c 4369
23f238d3
PA
4370static void
4371linux_resume_one_lwp (struct lwp_info *lwp,
4372 int step, int signal, siginfo_t *info)
4373{
4374 TRY
4375 {
4376 linux_resume_one_lwp_throw (lwp, step, signal, info);
4377 }
4378 CATCH (ex, RETURN_MASK_ERROR)
4379 {
4380 if (!check_ptrace_stopped_lwp_gone (lwp))
4381 throw_exception (ex);
3221518c 4382 }
23f238d3 4383 END_CATCH
da6d8c04
DJ
4384}
4385
2bd7c093
PA
4386struct thread_resume_array
4387{
4388 struct thread_resume *resume;
4389 size_t n;
4390};
64386c31 4391
ebcf782c
DE
4392/* This function is called once per thread via find_inferior.
4393 ARG is a pointer to a thread_resume_array struct.
4394 We look up the thread specified by ENTRY in ARG, and mark the thread
4395 with a pointer to the appropriate resume request.
5544ad89
DJ
4396
4397 This algorithm is O(threads * resume elements), but resume elements
4398 is small (and will remain small at least until GDB supports thread
4399 suspension). */
ebcf782c 4400
2bd7c093
PA
4401static int
4402linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
0d62e5e8 4403{
d86d4aaf
DE
4404 struct thread_info *thread = (struct thread_info *) entry;
4405 struct lwp_info *lwp = get_thread_lwp (thread);
5544ad89 4406 int ndx;
2bd7c093 4407 struct thread_resume_array *r;
64386c31 4408
9a3c8263 4409 r = (struct thread_resume_array *) arg;
64386c31 4410
2bd7c093 4411 for (ndx = 0; ndx < r->n; ndx++)
95954743
PA
4412 {
4413 ptid_t ptid = r->resume[ndx].thread;
4414 if (ptid_equal (ptid, minus_one_ptid)
4415 || ptid_equal (ptid, entry->id)
0c9070b3
YQ
4416 /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads
4417 of PID'. */
d86d4aaf 4418 || (ptid_get_pid (ptid) == pid_of (thread)
0c9070b3
YQ
4419 && (ptid_is_pid (ptid)
4420 || ptid_get_lwp (ptid) == -1)))
95954743 4421 {
d50171e4 4422 if (r->resume[ndx].kind == resume_stop
8336d594 4423 && thread->last_resume_kind == resume_stop)
d50171e4
PA
4424 {
4425 if (debug_threads)
87ce2a04
DE
4426 debug_printf ("already %s LWP %ld at GDB's request\n",
4427 (thread->last_status.kind
4428 == TARGET_WAITKIND_STOPPED)
4429 ? "stopped"
4430 : "stopping",
d86d4aaf 4431 lwpid_of (thread));
d50171e4
PA
4432
4433 continue;
4434 }
4435
95954743 4436 lwp->resume = &r->resume[ndx];
8336d594 4437 thread->last_resume_kind = lwp->resume->kind;
fa593d66 4438
c2d6af84
PA
4439 lwp->step_range_start = lwp->resume->step_range_start;
4440 lwp->step_range_end = lwp->resume->step_range_end;
4441
fa593d66
PA
4442 /* If we had a deferred signal to report, dequeue one now.
4443 This can happen if LWP gets more than one signal while
4444 trying to get out of a jump pad. */
4445 if (lwp->stopped
4446 && !lwp->status_pending_p
4447 && dequeue_one_deferred_signal (lwp, &lwp->status_pending))
4448 {
4449 lwp->status_pending_p = 1;
4450
4451 if (debug_threads)
87ce2a04
DE
4452 debug_printf ("Dequeueing deferred signal %d for LWP %ld, "
4453 "leaving status pending.\n",
d86d4aaf
DE
4454 WSTOPSIG (lwp->status_pending),
4455 lwpid_of (thread));
fa593d66
PA
4456 }
4457
95954743
PA
4458 return 0;
4459 }
4460 }
2bd7c093
PA
4461
4462 /* No resume action for this thread. */
4463 lwp->resume = NULL;
64386c31 4464
2bd7c093 4465 return 0;
5544ad89
DJ
4466}
4467
20ad9378
DE
4468/* find_inferior callback for linux_resume.
4469 Set *FLAG_P if this lwp has an interesting status pending. */
5544ad89 4470
bd99dc85
PA
4471static int
4472resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p)
5544ad89 4473{
d86d4aaf
DE
4474 struct thread_info *thread = (struct thread_info *) entry;
4475 struct lwp_info *lwp = get_thread_lwp (thread);
5544ad89 4476
bd99dc85
PA
4477 /* LWPs which will not be resumed are not interesting, because
4478 we might not wait for them next time through linux_wait. */
2bd7c093 4479 if (lwp->resume == NULL)
bd99dc85 4480 return 0;
64386c31 4481
582511be 4482 if (thread_still_has_status_pending_p (thread))
d50171e4
PA
4483 * (int *) flag_p = 1;
4484
4485 return 0;
4486}
4487
4488/* Return 1 if this lwp that GDB wants running is stopped at an
4489 internal breakpoint that we need to step over. It assumes that any
4490 required STOP_PC adjustment has already been propagated to the
4491 inferior's regcache. */
4492
4493static int
4494need_step_over_p (struct inferior_list_entry *entry, void *dummy)
4495{
d86d4aaf
DE
4496 struct thread_info *thread = (struct thread_info *) entry;
4497 struct lwp_info *lwp = get_thread_lwp (thread);
0bfdf32f 4498 struct thread_info *saved_thread;
d50171e4 4499 CORE_ADDR pc;
c06cbd92
YQ
4500 struct process_info *proc = get_thread_process (thread);
4501
4502 /* GDBserver is skipping the extra traps from the wrapper program,
4503 don't have to do step over. */
4504 if (proc->tdesc == NULL)
4505 return 0;
d50171e4
PA
4506
4507 /* LWPs which will not be resumed are not interesting, because we
4508 might not wait for them next time through linux_wait. */
4509
4510 if (!lwp->stopped)
4511 {
4512 if (debug_threads)
87ce2a04 4513 debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped\n",
d86d4aaf 4514 lwpid_of (thread));
d50171e4
PA
4515 return 0;
4516 }
4517
8336d594 4518 if (thread->last_resume_kind == resume_stop)
d50171e4
PA
4519 {
4520 if (debug_threads)
87ce2a04
DE
4521 debug_printf ("Need step over [LWP %ld]? Ignoring, should remain"
4522 " stopped\n",
d86d4aaf 4523 lwpid_of (thread));
d50171e4
PA
4524 return 0;
4525 }
4526
7984d532
PA
4527 gdb_assert (lwp->suspended >= 0);
4528
4529 if (lwp->suspended)
4530 {
4531 if (debug_threads)
87ce2a04 4532 debug_printf ("Need step over [LWP %ld]? Ignoring, suspended\n",
d86d4aaf 4533 lwpid_of (thread));
7984d532
PA
4534 return 0;
4535 }
4536
bd99dc85 4537 if (lwp->status_pending_p)
d50171e4
PA
4538 {
4539 if (debug_threads)
87ce2a04
DE
4540 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4541 " status.\n",
d86d4aaf 4542 lwpid_of (thread));
d50171e4
PA
4543 return 0;
4544 }
4545
4546 /* Note: PC, not STOP_PC. Either GDB has adjusted the PC already,
4547 or we have. */
4548 pc = get_pc (lwp);
4549
4550 /* If the PC has changed since we stopped, then don't do anything,
4551 and let the breakpoint/tracepoint be hit. This happens if, for
4552 instance, GDB handled the decr_pc_after_break subtraction itself,
4553 GDB is OOL stepping this thread, or the user has issued a "jump"
4554 command, or poked thread's registers herself. */
4555 if (pc != lwp->stop_pc)
4556 {
4557 if (debug_threads)
87ce2a04
DE
4558 debug_printf ("Need step over [LWP %ld]? Cancelling, PC was changed. "
4559 "Old stop_pc was 0x%s, PC is now 0x%s\n",
d86d4aaf
DE
4560 lwpid_of (thread),
4561 paddress (lwp->stop_pc), paddress (pc));
d50171e4
PA
4562 return 0;
4563 }
4564
484b3c32
YQ
4565 /* On software single step target, resume the inferior with signal
4566 rather than stepping over. */
4567 if (can_software_single_step ()
4568 && lwp->pending_signals != NULL
4569 && lwp_signal_can_be_delivered (lwp))
4570 {
4571 if (debug_threads)
4572 debug_printf ("Need step over [LWP %ld]? Ignoring, has pending"
4573 " signals.\n",
4574 lwpid_of (thread));
4575
4576 return 0;
4577 }
4578
0bfdf32f
GB
4579 saved_thread = current_thread;
4580 current_thread = thread;
d50171e4 4581
8b07ae33 4582 /* We can only step over breakpoints we know about. */
fa593d66 4583 if (breakpoint_here (pc) || fast_tracepoint_jump_here (pc))
d50171e4 4584 {
8b07ae33 4585 /* Don't step over a breakpoint that GDB expects to hit
9f3a5c85
LM
4586 though. If the condition is being evaluated on the target's side
4587 and it evaluate to false, step over this breakpoint as well. */
4588 if (gdb_breakpoint_here (pc)
d3ce09f5
SS
4589 && gdb_condition_true_at_breakpoint (pc)
4590 && gdb_no_commands_at_breakpoint (pc))
8b07ae33
PA
4591 {
4592 if (debug_threads)
87ce2a04
DE
4593 debug_printf ("Need step over [LWP %ld]? yes, but found"
4594 " GDB breakpoint at 0x%s; skipping step over\n",
d86d4aaf 4595 lwpid_of (thread), paddress (pc));
d50171e4 4596
0bfdf32f 4597 current_thread = saved_thread;
8b07ae33
PA
4598 return 0;
4599 }
4600 else
4601 {
4602 if (debug_threads)
87ce2a04
DE
4603 debug_printf ("Need step over [LWP %ld]? yes, "
4604 "found breakpoint at 0x%s\n",
d86d4aaf 4605 lwpid_of (thread), paddress (pc));
d50171e4 4606
8b07ae33
PA
4607 /* We've found an lwp that needs stepping over --- return 1 so
4608 that find_inferior stops looking. */
0bfdf32f 4609 current_thread = saved_thread;
8b07ae33 4610
8b07ae33
PA
4611 return 1;
4612 }
d50171e4
PA
4613 }
4614
0bfdf32f 4615 current_thread = saved_thread;
d50171e4
PA
4616
4617 if (debug_threads)
87ce2a04
DE
4618 debug_printf ("Need step over [LWP %ld]? No, no breakpoint found"
4619 " at 0x%s\n",
d86d4aaf 4620 lwpid_of (thread), paddress (pc));
c6ecbae5 4621
bd99dc85 4622 return 0;
5544ad89
DJ
4623}
4624
d50171e4
PA
4625/* Start a step-over operation on LWP. When LWP stopped at a
4626 breakpoint, to make progress, we need to remove the breakpoint out
4627 of the way. If we let other threads run while we do that, they may
4628 pass by the breakpoint location and miss hitting it. To avoid
4629 that, a step-over momentarily stops all threads while LWP is
c40c8d4b
YQ
4630 single-stepped by either hardware or software while the breakpoint
4631 is temporarily uninserted from the inferior. When the single-step
4632 finishes, we reinsert the breakpoint, and let all threads that are
4633 supposed to be running, run again. */
d50171e4
PA
4634
4635static int
4636start_step_over (struct lwp_info *lwp)
4637{
d86d4aaf 4638 struct thread_info *thread = get_lwp_thread (lwp);
0bfdf32f 4639 struct thread_info *saved_thread;
d50171e4
PA
4640 CORE_ADDR pc;
4641 int step;
4642
4643 if (debug_threads)
87ce2a04 4644 debug_printf ("Starting step-over on LWP %ld. Stopping all threads\n",
d86d4aaf 4645 lwpid_of (thread));
d50171e4 4646
7984d532 4647 stop_all_lwps (1, lwp);
863d01bd
PA
4648
4649 if (lwp->suspended != 0)
4650 {
4651 internal_error (__FILE__, __LINE__,
4652 "LWP %ld suspended=%d\n", lwpid_of (thread),
4653 lwp->suspended);
4654 }
d50171e4
PA
4655
4656 if (debug_threads)
87ce2a04 4657 debug_printf ("Done stopping all threads for step-over.\n");
d50171e4
PA
4658
4659 /* Note, we should always reach here with an already adjusted PC,
4660 either by GDB (if we're resuming due to GDB's request), or by our
4661 caller, if we just finished handling an internal breakpoint GDB
4662 shouldn't care about. */
4663 pc = get_pc (lwp);
4664
0bfdf32f
GB
4665 saved_thread = current_thread;
4666 current_thread = thread;
d50171e4
PA
4667
4668 lwp->bp_reinsert = pc;
4669 uninsert_breakpoints_at (pc);
fa593d66 4670 uninsert_fast_tracepoint_jumps_at (pc);
d50171e4 4671
7fe5e27e 4672 step = single_step (lwp);
d50171e4 4673
0bfdf32f 4674 current_thread = saved_thread;
d50171e4
PA
4675
4676 linux_resume_one_lwp (lwp, step, 0, NULL);
4677
4678 /* Require next event from this LWP. */
d86d4aaf 4679 step_over_bkpt = thread->entry.id;
d50171e4
PA
4680 return 1;
4681}
4682
4683/* Finish a step-over. Reinsert the breakpoint we had uninserted in
4684 start_step_over, if still there, and delete any reinsert
4685 breakpoints we've set, on non hardware single-step targets. */
4686
4687static int
4688finish_step_over (struct lwp_info *lwp)
4689{
4690 if (lwp->bp_reinsert != 0)
4691 {
4692 if (debug_threads)
87ce2a04 4693 debug_printf ("Finished step over.\n");
d50171e4
PA
4694
4695 /* Reinsert any breakpoint at LWP->BP_REINSERT. Note that there
4696 may be no breakpoint to reinsert there by now. */
4697 reinsert_breakpoints_at (lwp->bp_reinsert);
fa593d66 4698 reinsert_fast_tracepoint_jumps_at (lwp->bp_reinsert);
d50171e4
PA
4699
4700 lwp->bp_reinsert = 0;
4701
4702 /* Delete any software-single-step reinsert breakpoints. No
4703 longer needed. We don't have to worry about other threads
4704 hitting this trap, and later not being able to explain it,
4705 because we were stepping over a breakpoint, and we hold all
4706 threads but LWP stopped while doing that. */
4707 if (!can_hardware_single_step ())
4708 delete_reinsert_breakpoints ();
4709
4710 step_over_bkpt = null_ptid;
4711 return 1;
4712 }
4713 else
4714 return 0;
4715}
4716
863d01bd
PA
4717/* If there's a step over in progress, wait until all threads stop
4718 (that is, until the stepping thread finishes its step), and
4719 unsuspend all lwps. The stepping thread ends with its status
4720 pending, which is processed later when we get back to processing
4721 events. */
4722
4723static void
4724complete_ongoing_step_over (void)
4725{
4726 if (!ptid_equal (step_over_bkpt, null_ptid))
4727 {
4728 struct lwp_info *lwp;
4729 int wstat;
4730 int ret;
4731
4732 if (debug_threads)
4733 debug_printf ("detach: step over in progress, finish it first\n");
4734
4735 /* Passing NULL_PTID as filter indicates we want all events to
4736 be left pending. Eventually this returns when there are no
4737 unwaited-for children left. */
4738 ret = linux_wait_for_event_filtered (minus_one_ptid, null_ptid,
4739 &wstat, __WALL);
4740 gdb_assert (ret == -1);
4741
4742 lwp = find_lwp_pid (step_over_bkpt);
4743 if (lwp != NULL)
4744 finish_step_over (lwp);
4745 step_over_bkpt = null_ptid;
4746 unsuspend_all_lwps (lwp);
4747 }
4748}
4749
5544ad89
DJ
4750/* This function is called once per thread. We check the thread's resume
4751 request, which will tell us whether to resume, step, or leave the thread
bd99dc85 4752 stopped; and what signal, if any, it should be sent.
5544ad89 4753
bd99dc85
PA
4754 For threads which we aren't explicitly told otherwise, we preserve
4755 the stepping flag; this is used for stepping over gdbserver-placed
4756 breakpoints.
4757
4758 If pending_flags was set in any thread, we queue any needed
4759 signals, since we won't actually resume. We already have a pending
4760 event to report, so we don't need to preserve any step requests;
4761 they should be re-issued if necessary. */
4762
4763static int
4764linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
5544ad89 4765{
d86d4aaf
DE
4766 struct thread_info *thread = (struct thread_info *) entry;
4767 struct lwp_info *lwp = get_thread_lwp (thread);
bd99dc85 4768 int step;
d50171e4
PA
4769 int leave_all_stopped = * (int *) arg;
4770 int leave_pending;
5544ad89 4771
2bd7c093 4772 if (lwp->resume == NULL)
bd99dc85 4773 return 0;
5544ad89 4774
bd99dc85 4775 if (lwp->resume->kind == resume_stop)
5544ad89 4776 {
bd99dc85 4777 if (debug_threads)
d86d4aaf 4778 debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (thread));
bd99dc85
PA
4779
4780 if (!lwp->stopped)
4781 {
4782 if (debug_threads)
d86d4aaf 4783 debug_printf ("stopping LWP %ld\n", lwpid_of (thread));
bd99dc85 4784
d50171e4
PA
4785 /* Stop the thread, and wait for the event asynchronously,
4786 through the event loop. */
02fc4de7 4787 send_sigstop (lwp);
bd99dc85
PA
4788 }
4789 else
4790 {
4791 if (debug_threads)
87ce2a04 4792 debug_printf ("already stopped LWP %ld\n",
d86d4aaf 4793 lwpid_of (thread));
d50171e4
PA
4794
4795 /* The LWP may have been stopped in an internal event that
4796 was not meant to be notified back to GDB (e.g., gdbserver
4797 breakpoint), so we should be reporting a stop event in
4798 this case too. */
4799
4800 /* If the thread already has a pending SIGSTOP, this is a
4801 no-op. Otherwise, something later will presumably resume
4802 the thread and this will cause it to cancel any pending
4803 operation, due to last_resume_kind == resume_stop. If
4804 the thread already has a pending status to report, we
4805 will still report it the next time we wait - see
4806 status_pending_p_callback. */
1a981360
PA
4807
4808 /* If we already have a pending signal to report, then
4809 there's no need to queue a SIGSTOP, as this means we're
4810 midway through moving the LWP out of the jumppad, and we
4811 will report the pending signal as soon as that is
4812 finished. */
4813 if (lwp->pending_signals_to_report == NULL)
4814 send_sigstop (lwp);
bd99dc85 4815 }
32ca6d61 4816
bd99dc85
PA
4817 /* For stop requests, we're done. */
4818 lwp->resume = NULL;
fc7238bb 4819 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
bd99dc85 4820 return 0;
5544ad89
DJ
4821 }
4822
bd99dc85 4823 /* If this thread which is about to be resumed has a pending status,
863d01bd
PA
4824 then don't resume it - we can just report the pending status.
4825 Likewise if it is suspended, because e.g., another thread is
4826 stepping past a breakpoint. Make sure to queue any signals that
4827 would otherwise be sent. In all-stop mode, we do this decision
4828 based on if *any* thread has a pending status. If there's a
4829 thread that needs the step-over-breakpoint dance, then don't
4830 resume any other thread but that particular one. */
4831 leave_pending = (lwp->suspended
4832 || lwp->status_pending_p
4833 || leave_all_stopped);
5544ad89 4834
d50171e4 4835 if (!leave_pending)
bd99dc85
PA
4836 {
4837 if (debug_threads)
d86d4aaf 4838 debug_printf ("resuming LWP %ld\n", lwpid_of (thread));
5544ad89 4839
d50171e4 4840 step = (lwp->resume->kind == resume_step);
2acc282a 4841 linux_resume_one_lwp (lwp, step, lwp->resume->sig, NULL);
bd99dc85
PA
4842 }
4843 else
4844 {
4845 if (debug_threads)
d86d4aaf 4846 debug_printf ("leaving LWP %ld stopped\n", lwpid_of (thread));
5544ad89 4847
bd99dc85
PA
4848 /* If we have a new signal, enqueue the signal. */
4849 if (lwp->resume->sig != 0)
4850 {
8d749320
SM
4851 struct pending_signals *p_sig = XCNEW (struct pending_signals);
4852
bd99dc85
PA
4853 p_sig->prev = lwp->pending_signals;
4854 p_sig->signal = lwp->resume->sig;
bd99dc85
PA
4855
4856 /* If this is the same signal we were previously stopped by,
4857 make sure to queue its siginfo. We can ignore the return
4858 value of ptrace; if it fails, we'll skip
4859 PTRACE_SETSIGINFO. */
4860 if (WIFSTOPPED (lwp->last_status)
4861 && WSTOPSIG (lwp->last_status) == lwp->resume->sig)
d86d4aaf 4862 ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
56f7af9c 4863 &p_sig->info);
bd99dc85
PA
4864
4865 lwp->pending_signals = p_sig;
4866 }
4867 }
5544ad89 4868
fc7238bb 4869 thread->last_status.kind = TARGET_WAITKIND_IGNORE;
bd99dc85 4870 lwp->resume = NULL;
5544ad89 4871 return 0;
0d62e5e8
DJ
4872}
4873
4874static void
2bd7c093 4875linux_resume (struct thread_resume *resume_info, size_t n)
0d62e5e8 4876{
2bd7c093 4877 struct thread_resume_array array = { resume_info, n };
d86d4aaf 4878 struct thread_info *need_step_over = NULL;
d50171e4
PA
4879 int any_pending;
4880 int leave_all_stopped;
c6ecbae5 4881
87ce2a04
DE
4882 if (debug_threads)
4883 {
4884 debug_enter ();
4885 debug_printf ("linux_resume:\n");
4886 }
4887
2bd7c093 4888 find_inferior (&all_threads, linux_set_resume_request, &array);
5544ad89 4889
d50171e4
PA
4890 /* If there is a thread which would otherwise be resumed, which has
4891 a pending status, then don't resume any threads - we can just
4892 report the pending status. Make sure to queue any signals that
4893 would otherwise be sent. In non-stop mode, we'll apply this
4894 logic to each thread individually. We consume all pending events
4895 before considering to start a step-over (in all-stop). */
4896 any_pending = 0;
bd99dc85 4897 if (!non_stop)
d86d4aaf 4898 find_inferior (&all_threads, resume_status_pending_p, &any_pending);
d50171e4
PA
4899
4900 /* If there is a thread which would otherwise be resumed, which is
4901 stopped at a breakpoint that needs stepping over, then don't
4902 resume any threads - have it step over the breakpoint with all
4903 other threads stopped, then resume all threads again. Make sure
4904 to queue any signals that would otherwise be delivered or
4905 queued. */
4906 if (!any_pending && supports_breakpoints ())
4907 need_step_over
d86d4aaf
DE
4908 = (struct thread_info *) find_inferior (&all_threads,
4909 need_step_over_p, NULL);
d50171e4
PA
4910
4911 leave_all_stopped = (need_step_over != NULL || any_pending);
4912
4913 if (debug_threads)
4914 {
4915 if (need_step_over != NULL)
87ce2a04 4916 debug_printf ("Not resuming all, need step over\n");
d50171e4 4917 else if (any_pending)
87ce2a04
DE
4918 debug_printf ("Not resuming, all-stop and found "
4919 "an LWP with pending status\n");
d50171e4 4920 else
87ce2a04 4921 debug_printf ("Resuming, no pending status or step over needed\n");
d50171e4
PA
4922 }
4923
4924 /* Even if we're leaving threads stopped, queue all signals we'd
4925 otherwise deliver. */
4926 find_inferior (&all_threads, linux_resume_one_thread, &leave_all_stopped);
4927
4928 if (need_step_over)
d86d4aaf 4929 start_step_over (get_thread_lwp (need_step_over));
87ce2a04
DE
4930
4931 if (debug_threads)
4932 {
4933 debug_printf ("linux_resume done\n");
4934 debug_exit ();
4935 }
1bebeeca
PA
4936
4937 /* We may have events that were pending that can/should be sent to
4938 the client now. Trigger a linux_wait call. */
4939 if (target_is_async_p ())
4940 async_file_mark ();
d50171e4
PA
4941}
4942
4943/* This function is called once per thread. We check the thread's
4944 last resume request, which will tell us whether to resume, step, or
4945 leave the thread stopped. Any signal the client requested to be
4946 delivered has already been enqueued at this point.
4947
4948 If any thread that GDB wants running is stopped at an internal
4949 breakpoint that needs stepping over, we start a step-over operation
4950 on that particular thread, and leave all others stopped. */
4951
7984d532
PA
4952static int
4953proceed_one_lwp (struct inferior_list_entry *entry, void *except)
d50171e4 4954{
d86d4aaf
DE
4955 struct thread_info *thread = (struct thread_info *) entry;
4956 struct lwp_info *lwp = get_thread_lwp (thread);
d50171e4
PA
4957 int step;
4958
7984d532
PA
4959 if (lwp == except)
4960 return 0;
d50171e4
PA
4961
4962 if (debug_threads)
d86d4aaf 4963 debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (thread));
d50171e4
PA
4964
4965 if (!lwp->stopped)
4966 {
4967 if (debug_threads)
d86d4aaf 4968 debug_printf (" LWP %ld already running\n", lwpid_of (thread));
7984d532 4969 return 0;
d50171e4
PA
4970 }
4971
02fc4de7
PA
4972 if (thread->last_resume_kind == resume_stop
4973 && thread->last_status.kind != TARGET_WAITKIND_IGNORE)
d50171e4
PA
4974 {
4975 if (debug_threads)
87ce2a04 4976 debug_printf (" client wants LWP to remain %ld stopped\n",
d86d4aaf 4977 lwpid_of (thread));
7984d532 4978 return 0;
d50171e4
PA
4979 }
4980
4981 if (lwp->status_pending_p)
4982 {
4983 if (debug_threads)
87ce2a04 4984 debug_printf (" LWP %ld has pending status, leaving stopped\n",
d86d4aaf 4985 lwpid_of (thread));
7984d532 4986 return 0;
d50171e4
PA
4987 }
4988
7984d532
PA
4989 gdb_assert (lwp->suspended >= 0);
4990
d50171e4
PA
4991 if (lwp->suspended)
4992 {
4993 if (debug_threads)
d86d4aaf 4994 debug_printf (" LWP %ld is suspended\n", lwpid_of (thread));
7984d532 4995 return 0;
d50171e4
PA
4996 }
4997
1a981360
PA
4998 if (thread->last_resume_kind == resume_stop
4999 && lwp->pending_signals_to_report == NULL
5000 && lwp->collecting_fast_tracepoint == 0)
02fc4de7
PA
5001 {
5002 /* We haven't reported this LWP as stopped yet (otherwise, the
5003 last_status.kind check above would catch it, and we wouldn't
5004 reach here. This LWP may have been momentarily paused by a
5005 stop_all_lwps call while handling for example, another LWP's
5006 step-over. In that case, the pending expected SIGSTOP signal
5007 that was queued at vCont;t handling time will have already
5008 been consumed by wait_for_sigstop, and so we need to requeue
5009 another one here. Note that if the LWP already has a SIGSTOP
5010 pending, this is a no-op. */
5011
5012 if (debug_threads)
87ce2a04
DE
5013 debug_printf ("Client wants LWP %ld to stop. "
5014 "Making sure it has a SIGSTOP pending\n",
d86d4aaf 5015 lwpid_of (thread));
02fc4de7
PA
5016
5017 send_sigstop (lwp);
5018 }
5019
863d01bd
PA
5020 if (thread->last_resume_kind == resume_step)
5021 {
5022 if (debug_threads)
5023 debug_printf (" stepping LWP %ld, client wants it stepping\n",
5024 lwpid_of (thread));
5025 step = 1;
5026 }
5027 else if (lwp->bp_reinsert != 0)
5028 {
5029 if (debug_threads)
5030 debug_printf (" stepping LWP %ld, reinsert set\n",
5031 lwpid_of (thread));
5032 step = 1;
5033 }
5034 else
5035 step = 0;
5036
d50171e4 5037 linux_resume_one_lwp (lwp, step, 0, NULL);
7984d532
PA
5038 return 0;
5039}
5040
5041static int
5042unsuspend_and_proceed_one_lwp (struct inferior_list_entry *entry, void *except)
5043{
d86d4aaf
DE
5044 struct thread_info *thread = (struct thread_info *) entry;
5045 struct lwp_info *lwp = get_thread_lwp (thread);
7984d532
PA
5046
5047 if (lwp == except)
5048 return 0;
5049
863d01bd 5050 lwp_suspended_decr (lwp);
7984d532
PA
5051
5052 return proceed_one_lwp (entry, except);
d50171e4
PA
5053}
5054
5055/* When we finish a step-over, set threads running again. If there's
5056 another thread that may need a step-over, now's the time to start
5057 it. Eventually, we'll move all threads past their breakpoints. */
5058
5059static void
5060proceed_all_lwps (void)
5061{
d86d4aaf 5062 struct thread_info *need_step_over;
d50171e4
PA
5063
5064 /* If there is a thread which would otherwise be resumed, which is
5065 stopped at a breakpoint that needs stepping over, then don't
5066 resume any threads - have it step over the breakpoint with all
5067 other threads stopped, then resume all threads again. */
5068
5069 if (supports_breakpoints ())
5070 {
5071 need_step_over
d86d4aaf
DE
5072 = (struct thread_info *) find_inferior (&all_threads,
5073 need_step_over_p, NULL);
d50171e4
PA
5074
5075 if (need_step_over != NULL)
5076 {
5077 if (debug_threads)
87ce2a04
DE
5078 debug_printf ("proceed_all_lwps: found "
5079 "thread %ld needing a step-over\n",
5080 lwpid_of (need_step_over));
d50171e4 5081
d86d4aaf 5082 start_step_over (get_thread_lwp (need_step_over));
d50171e4
PA
5083 return;
5084 }
5085 }
5544ad89 5086
d50171e4 5087 if (debug_threads)
87ce2a04 5088 debug_printf ("Proceeding, no step-over needed\n");
d50171e4 5089
d86d4aaf 5090 find_inferior (&all_threads, proceed_one_lwp, NULL);
d50171e4
PA
5091}
5092
5093/* Stopped LWPs that the client wanted to be running, that don't have
5094 pending statuses, are set to run again, except for EXCEPT, if not
5095 NULL. This undoes a stop_all_lwps call. */
5096
5097static void
7984d532 5098unstop_all_lwps (int unsuspend, struct lwp_info *except)
d50171e4 5099{
5544ad89
DJ
5100 if (debug_threads)
5101 {
87ce2a04 5102 debug_enter ();
d50171e4 5103 if (except)
87ce2a04 5104 debug_printf ("unstopping all lwps, except=(LWP %ld)\n",
d86d4aaf 5105 lwpid_of (get_lwp_thread (except)));
5544ad89 5106 else
87ce2a04 5107 debug_printf ("unstopping all lwps\n");
5544ad89
DJ
5108 }
5109
7984d532 5110 if (unsuspend)
d86d4aaf 5111 find_inferior (&all_threads, unsuspend_and_proceed_one_lwp, except);
7984d532 5112 else
d86d4aaf 5113 find_inferior (&all_threads, proceed_one_lwp, except);
87ce2a04
DE
5114
5115 if (debug_threads)
5116 {
5117 debug_printf ("unstop_all_lwps done\n");
5118 debug_exit ();
5119 }
0d62e5e8
DJ
5120}
5121
58caa3dc
DJ
5122
5123#ifdef HAVE_LINUX_REGSETS
5124
1faeff08
MR
5125#define use_linux_regsets 1
5126
030031ee
PA
5127/* Returns true if REGSET has been disabled. */
5128
5129static int
5130regset_disabled (struct regsets_info *info, struct regset_info *regset)
5131{
5132 return (info->disabled_regsets != NULL
5133 && info->disabled_regsets[regset - info->regsets]);
5134}
5135
5136/* Disable REGSET. */
5137
5138static void
5139disable_regset (struct regsets_info *info, struct regset_info *regset)
5140{
5141 int dr_offset;
5142
5143 dr_offset = regset - info->regsets;
5144 if (info->disabled_regsets == NULL)
224c3ddb 5145 info->disabled_regsets = (char *) xcalloc (1, info->num_regsets);
030031ee
PA
5146 info->disabled_regsets[dr_offset] = 1;
5147}
5148
58caa3dc 5149static int
3aee8918
PA
5150regsets_fetch_inferior_registers (struct regsets_info *regsets_info,
5151 struct regcache *regcache)
58caa3dc
DJ
5152{
5153 struct regset_info *regset;
e9d25b98 5154 int saw_general_regs = 0;
95954743 5155 int pid;
1570b33e 5156 struct iovec iov;
58caa3dc 5157
0bfdf32f 5158 pid = lwpid_of (current_thread);
28eef672 5159 for (regset = regsets_info->regsets; regset->size >= 0; regset++)
58caa3dc 5160 {
1570b33e
L
5161 void *buf, *data;
5162 int nt_type, res;
58caa3dc 5163
030031ee 5164 if (regset->size == 0 || regset_disabled (regsets_info, regset))
28eef672 5165 continue;
58caa3dc 5166
bca929d3 5167 buf = xmalloc (regset->size);
1570b33e
L
5168
5169 nt_type = regset->nt_type;
5170 if (nt_type)
5171 {
5172 iov.iov_base = buf;
5173 iov.iov_len = regset->size;
5174 data = (void *) &iov;
5175 }
5176 else
5177 data = buf;
5178
dfb64f85 5179#ifndef __sparc__
f15f9948 5180 res = ptrace (regset->get_request, pid,
b8e1b30e 5181 (PTRACE_TYPE_ARG3) (long) nt_type, data);
dfb64f85 5182#else
1570b33e 5183 res = ptrace (regset->get_request, pid, data, nt_type);
dfb64f85 5184#endif
58caa3dc
DJ
5185 if (res < 0)
5186 {
5187 if (errno == EIO)
5188 {
52fa2412 5189 /* If we get EIO on a regset, do not try it again for
3aee8918 5190 this process mode. */
030031ee 5191 disable_regset (regsets_info, regset);
58caa3dc 5192 }
e5a9158d
AA
5193 else if (errno == ENODATA)
5194 {
5195 /* ENODATA may be returned if the regset is currently
5196 not "active". This can happen in normal operation,
5197 so suppress the warning in this case. */
5198 }
58caa3dc
DJ
5199 else
5200 {
0d62e5e8 5201 char s[256];
95954743
PA
5202 sprintf (s, "ptrace(regsets_fetch_inferior_registers) PID=%d",
5203 pid);
0d62e5e8 5204 perror (s);
58caa3dc
DJ
5205 }
5206 }
098dbe61
AA
5207 else
5208 {
5209 if (regset->type == GENERAL_REGS)
5210 saw_general_regs = 1;
5211 regset->store_function (regcache, buf);
5212 }
fdeb2a12 5213 free (buf);
58caa3dc 5214 }
e9d25b98
DJ
5215 if (saw_general_regs)
5216 return 0;
5217 else
5218 return 1;
58caa3dc
DJ
5219}
5220
5221static int
3aee8918
PA
5222regsets_store_inferior_registers (struct regsets_info *regsets_info,
5223 struct regcache *regcache)
58caa3dc
DJ
5224{
5225 struct regset_info *regset;
e9d25b98 5226 int saw_general_regs = 0;
95954743 5227 int pid;
1570b33e 5228 struct iovec iov;
58caa3dc 5229
0bfdf32f 5230 pid = lwpid_of (current_thread);
28eef672 5231 for (regset = regsets_info->regsets; regset->size >= 0; regset++)
58caa3dc 5232 {
1570b33e
L
5233 void *buf, *data;
5234 int nt_type, res;
58caa3dc 5235
feea5f36
AA
5236 if (regset->size == 0 || regset_disabled (regsets_info, regset)
5237 || regset->fill_function == NULL)
28eef672 5238 continue;
58caa3dc 5239
bca929d3 5240 buf = xmalloc (regset->size);
545587ee
DJ
5241
5242 /* First fill the buffer with the current register set contents,
5243 in case there are any items in the kernel's regset that are
5244 not in gdbserver's regcache. */
1570b33e
L
5245
5246 nt_type = regset->nt_type;
5247 if (nt_type)
5248 {
5249 iov.iov_base = buf;
5250 iov.iov_len = regset->size;
5251 data = (void *) &iov;
5252 }
5253 else
5254 data = buf;
5255
dfb64f85 5256#ifndef __sparc__
f15f9948 5257 res = ptrace (regset->get_request, pid,
b8e1b30e 5258 (PTRACE_TYPE_ARG3) (long) nt_type, data);
dfb64f85 5259#else
689cc2ae 5260 res = ptrace (regset->get_request, pid, data, nt_type);
dfb64f85 5261#endif
545587ee
DJ
5262
5263 if (res == 0)
5264 {
5265 /* Then overlay our cached registers on that. */
442ea881 5266 regset->fill_function (regcache, buf);
545587ee
DJ
5267
5268 /* Only now do we write the register set. */
dfb64f85 5269#ifndef __sparc__
f15f9948 5270 res = ptrace (regset->set_request, pid,
b8e1b30e 5271 (PTRACE_TYPE_ARG3) (long) nt_type, data);
dfb64f85 5272#else
1570b33e 5273 res = ptrace (regset->set_request, pid, data, nt_type);
dfb64f85 5274#endif
545587ee
DJ
5275 }
5276
58caa3dc
DJ
5277 if (res < 0)
5278 {
5279 if (errno == EIO)
5280 {
52fa2412 5281 /* If we get EIO on a regset, do not try it again for
3aee8918 5282 this process mode. */
030031ee 5283 disable_regset (regsets_info, regset);
58caa3dc 5284 }
3221518c
UW
5285 else if (errno == ESRCH)
5286 {
1b3f6016
PA
5287 /* At this point, ESRCH should mean the process is
5288 already gone, in which case we simply ignore attempts
5289 to change its registers. See also the related
5290 comment in linux_resume_one_lwp. */
fdeb2a12 5291 free (buf);
3221518c
UW
5292 return 0;
5293 }
58caa3dc
DJ
5294 else
5295 {
ce3a066d 5296 perror ("Warning: ptrace(regsets_store_inferior_registers)");
58caa3dc
DJ
5297 }
5298 }
e9d25b98
DJ
5299 else if (regset->type == GENERAL_REGS)
5300 saw_general_regs = 1;
09ec9b38 5301 free (buf);
58caa3dc 5302 }
e9d25b98
DJ
5303 if (saw_general_regs)
5304 return 0;
5305 else
5306 return 1;
58caa3dc
DJ
5307}
5308
1faeff08 5309#else /* !HAVE_LINUX_REGSETS */
58caa3dc 5310
1faeff08 5311#define use_linux_regsets 0
3aee8918
PA
5312#define regsets_fetch_inferior_registers(regsets_info, regcache) 1
5313#define regsets_store_inferior_registers(regsets_info, regcache) 1
58caa3dc 5314
58caa3dc 5315#endif
1faeff08
MR
5316
5317/* Return 1 if register REGNO is supported by one of the regset ptrace
5318 calls or 0 if it has to be transferred individually. */
5319
5320static int
3aee8918 5321linux_register_in_regsets (const struct regs_info *regs_info, int regno)
1faeff08
MR
5322{
5323 unsigned char mask = 1 << (regno % 8);
5324 size_t index = regno / 8;
5325
5326 return (use_linux_regsets
3aee8918
PA
5327 && (regs_info->regset_bitmap == NULL
5328 || (regs_info->regset_bitmap[index] & mask) != 0));
1faeff08
MR
5329}
5330
58caa3dc 5331#ifdef HAVE_LINUX_USRREGS
1faeff08 5332
5b3da067 5333static int
3aee8918 5334register_addr (const struct usrregs_info *usrregs, int regnum)
1faeff08
MR
5335{
5336 int addr;
5337
3aee8918 5338 if (regnum < 0 || regnum >= usrregs->num_regs)
1faeff08
MR
5339 error ("Invalid register number %d.", regnum);
5340
3aee8918 5341 addr = usrregs->regmap[regnum];
1faeff08
MR
5342
5343 return addr;
5344}
5345
5346/* Fetch one register. */
5347static void
3aee8918
PA
5348fetch_register (const struct usrregs_info *usrregs,
5349 struct regcache *regcache, int regno)
1faeff08
MR
5350{
5351 CORE_ADDR regaddr;
5352 int i, size;
5353 char *buf;
5354 int pid;
5355
3aee8918 5356 if (regno >= usrregs->num_regs)
1faeff08
MR
5357 return;
5358 if ((*the_low_target.cannot_fetch_register) (regno))
5359 return;
5360
3aee8918 5361 regaddr = register_addr (usrregs, regno);
1faeff08
MR
5362 if (regaddr == -1)
5363 return;
5364
3aee8918
PA
5365 size = ((register_size (regcache->tdesc, regno)
5366 + sizeof (PTRACE_XFER_TYPE) - 1)
1faeff08 5367 & -sizeof (PTRACE_XFER_TYPE));
224c3ddb 5368 buf = (char *) alloca (size);
1faeff08 5369
0bfdf32f 5370 pid = lwpid_of (current_thread);
1faeff08
MR
5371 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
5372 {
5373 errno = 0;
5374 *(PTRACE_XFER_TYPE *) (buf + i) =
5375 ptrace (PTRACE_PEEKUSER, pid,
5376 /* Coerce to a uintptr_t first to avoid potential gcc warning
5377 of coercing an 8 byte integer to a 4 byte pointer. */
b8e1b30e 5378 (PTRACE_TYPE_ARG3) (uintptr_t) regaddr, (PTRACE_TYPE_ARG4) 0);
1faeff08
MR
5379 regaddr += sizeof (PTRACE_XFER_TYPE);
5380 if (errno != 0)
5381 error ("reading register %d: %s", regno, strerror (errno));
5382 }
5383
5384 if (the_low_target.supply_ptrace_register)
5385 the_low_target.supply_ptrace_register (regcache, regno, buf);
5386 else
5387 supply_register (regcache, regno, buf);
5388}
5389
5390/* Store one register. */
5391static void
3aee8918
PA
5392store_register (const struct usrregs_info *usrregs,
5393 struct regcache *regcache, int regno)
1faeff08
MR
5394{
5395 CORE_ADDR regaddr;
5396 int i, size;
5397 char *buf;
5398 int pid;
5399
3aee8918 5400 if (regno >= usrregs->num_regs)
1faeff08
MR
5401 return;
5402 if ((*the_low_target.cannot_store_register) (regno))
5403 return;
5404
3aee8918 5405 regaddr = register_addr (usrregs, regno);
1faeff08
MR
5406 if (regaddr == -1)
5407 return;
5408
3aee8918
PA
5409 size = ((register_size (regcache->tdesc, regno)
5410 + sizeof (PTRACE_XFER_TYPE) - 1)
1faeff08 5411 & -sizeof (PTRACE_XFER_TYPE));
224c3ddb 5412 buf = (char *) alloca (size);
1faeff08
MR
5413 memset (buf, 0, size);
5414
5415 if (the_low_target.collect_ptrace_register)
5416 the_low_target.collect_ptrace_register (regcache, regno, buf);
5417 else
5418 collect_register (regcache, regno, buf);
5419
0bfdf32f 5420 pid = lwpid_of (current_thread);
1faeff08
MR
5421 for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE))
5422 {
5423 errno = 0;
5424 ptrace (PTRACE_POKEUSER, pid,
5425 /* Coerce to a uintptr_t first to avoid potential gcc warning
5426 about coercing an 8 byte integer to a 4 byte pointer. */
b8e1b30e
LM
5427 (PTRACE_TYPE_ARG3) (uintptr_t) regaddr,
5428 (PTRACE_TYPE_ARG4) *(PTRACE_XFER_TYPE *) (buf + i));
1faeff08
MR
5429 if (errno != 0)
5430 {
5431 /* At this point, ESRCH should mean the process is
5432 already gone, in which case we simply ignore attempts
5433 to change its registers. See also the related
5434 comment in linux_resume_one_lwp. */
5435 if (errno == ESRCH)
5436 return;
5437
5438 if ((*the_low_target.cannot_store_register) (regno) == 0)
5439 error ("writing register %d: %s", regno, strerror (errno));
5440 }
5441 regaddr += sizeof (PTRACE_XFER_TYPE);
5442 }
5443}
5444
5445/* Fetch all registers, or just one, from the child process.
5446 If REGNO is -1, do this for all registers, skipping any that are
5447 assumed to have been retrieved by regsets_fetch_inferior_registers,
5448 unless ALL is non-zero.
5449 Otherwise, REGNO specifies which register (so we can save time). */
5450static void
3aee8918
PA
5451usr_fetch_inferior_registers (const struct regs_info *regs_info,
5452 struct regcache *regcache, int regno, int all)
1faeff08 5453{
3aee8918
PA
5454 struct usrregs_info *usr = regs_info->usrregs;
5455
1faeff08
MR
5456 if (regno == -1)
5457 {
3aee8918
PA
5458 for (regno = 0; regno < usr->num_regs; regno++)
5459 if (all || !linux_register_in_regsets (regs_info, regno))
5460 fetch_register (usr, regcache, regno);
1faeff08
MR
5461 }
5462 else
3aee8918 5463 fetch_register (usr, regcache, regno);
1faeff08
MR
5464}
5465
5466/* Store our register values back into the inferior.
5467 If REGNO is -1, do this for all registers, skipping any that are
5468 assumed to have been saved by regsets_store_inferior_registers,
5469 unless ALL is non-zero.
5470 Otherwise, REGNO specifies which register (so we can save time). */
5471static void
3aee8918
PA
5472usr_store_inferior_registers (const struct regs_info *regs_info,
5473 struct regcache *regcache, int regno, int all)
1faeff08 5474{
3aee8918
PA
5475 struct usrregs_info *usr = regs_info->usrregs;
5476
1faeff08
MR
5477 if (regno == -1)
5478 {
3aee8918
PA
5479 for (regno = 0; regno < usr->num_regs; regno++)
5480 if (all || !linux_register_in_regsets (regs_info, regno))
5481 store_register (usr, regcache, regno);
1faeff08
MR
5482 }
5483 else
3aee8918 5484 store_register (usr, regcache, regno);
1faeff08
MR
5485}
5486
5487#else /* !HAVE_LINUX_USRREGS */
5488
3aee8918
PA
5489#define usr_fetch_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
5490#define usr_store_inferior_registers(regs_info, regcache, regno, all) do {} while (0)
1faeff08 5491
58caa3dc 5492#endif
1faeff08
MR
5493
5494
5b3da067 5495static void
1faeff08
MR
5496linux_fetch_registers (struct regcache *regcache, int regno)
5497{
5498 int use_regsets;
5499 int all = 0;
3aee8918 5500 const struct regs_info *regs_info = (*the_low_target.regs_info) ();
1faeff08
MR
5501
5502 if (regno == -1)
5503 {
3aee8918
PA
5504 if (the_low_target.fetch_register != NULL
5505 && regs_info->usrregs != NULL)
5506 for (regno = 0; regno < regs_info->usrregs->num_regs; regno++)
c14dfd32
PA
5507 (*the_low_target.fetch_register) (regcache, regno);
5508
3aee8918
PA
5509 all = regsets_fetch_inferior_registers (regs_info->regsets_info, regcache);
5510 if (regs_info->usrregs != NULL)
5511 usr_fetch_inferior_registers (regs_info, regcache, -1, all);
1faeff08
MR
5512 }
5513 else
5514 {
c14dfd32
PA
5515 if (the_low_target.fetch_register != NULL
5516 && (*the_low_target.fetch_register) (regcache, regno))
5517 return;
5518
3aee8918 5519 use_regsets = linux_register_in_regsets (regs_info, regno);
1faeff08 5520 if (use_regsets)
3aee8918
PA
5521 all = regsets_fetch_inferior_registers (regs_info->regsets_info,
5522 regcache);
5523 if ((!use_regsets || all) && regs_info->usrregs != NULL)
5524 usr_fetch_inferior_registers (regs_info, regcache, regno, 1);
1faeff08 5525 }
58caa3dc
DJ
5526}
5527
5b3da067 5528static void
442ea881 5529linux_store_registers (struct regcache *regcache, int regno)
58caa3dc 5530{
1faeff08
MR
5531 int use_regsets;
5532 int all = 0;
3aee8918 5533 const struct regs_info *regs_info = (*the_low_target.regs_info) ();
1faeff08
MR
5534
5535 if (regno == -1)
5536 {
3aee8918
PA
5537 all = regsets_store_inferior_registers (regs_info->regsets_info,
5538 regcache);
5539 if (regs_info->usrregs != NULL)
5540 usr_store_inferior_registers (regs_info, regcache, regno, all);
1faeff08
MR
5541 }
5542 else
5543 {
3aee8918 5544 use_regsets = linux_register_in_regsets (regs_info, regno);
1faeff08 5545 if (use_regsets)
3aee8918
PA
5546 all = regsets_store_inferior_registers (regs_info->regsets_info,
5547 regcache);
5548 if ((!use_regsets || all) && regs_info->usrregs != NULL)
5549 usr_store_inferior_registers (regs_info, regcache, regno, 1);
1faeff08 5550 }
58caa3dc
DJ
5551}
5552
da6d8c04 5553
da6d8c04
DJ
5554/* Copy LEN bytes from inferior's memory starting at MEMADDR
5555 to debugger memory starting at MYADDR. */
5556
c3e735a6 5557static int
f450004a 5558linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
da6d8c04 5559{
0bfdf32f 5560 int pid = lwpid_of (current_thread);
4934b29e
MR
5561 register PTRACE_XFER_TYPE *buffer;
5562 register CORE_ADDR addr;
5563 register int count;
5564 char filename[64];
da6d8c04 5565 register int i;
4934b29e 5566 int ret;
fd462a61 5567 int fd;
fd462a61
DJ
5568
5569 /* Try using /proc. Don't bother for one word. */
5570 if (len >= 3 * sizeof (long))
5571 {
4934b29e
MR
5572 int bytes;
5573
fd462a61
DJ
5574 /* We could keep this file open and cache it - possibly one per
5575 thread. That requires some juggling, but is even faster. */
95954743 5576 sprintf (filename, "/proc/%d/mem", pid);
fd462a61
DJ
5577 fd = open (filename, O_RDONLY | O_LARGEFILE);
5578 if (fd == -1)
5579 goto no_proc;
5580
5581 /* If pread64 is available, use it. It's faster if the kernel
5582 supports it (only one syscall), and it's 64-bit safe even on
5583 32-bit platforms (for instance, SPARC debugging a SPARC64
5584 application). */
5585#ifdef HAVE_PREAD64
4934b29e 5586 bytes = pread64 (fd, myaddr, len, memaddr);
fd462a61 5587#else
4934b29e
MR
5588 bytes = -1;
5589 if (lseek (fd, memaddr, SEEK_SET) != -1)
5590 bytes = read (fd, myaddr, len);
fd462a61 5591#endif
fd462a61
DJ
5592
5593 close (fd);
4934b29e
MR
5594 if (bytes == len)
5595 return 0;
5596
5597 /* Some data was read, we'll try to get the rest with ptrace. */
5598 if (bytes > 0)
5599 {
5600 memaddr += bytes;
5601 myaddr += bytes;
5602 len -= bytes;
5603 }
fd462a61 5604 }
da6d8c04 5605
fd462a61 5606 no_proc:
4934b29e
MR
5607 /* Round starting address down to longword boundary. */
5608 addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
5609 /* Round ending address up; get number of longwords that makes. */
5610 count = ((((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
5611 / sizeof (PTRACE_XFER_TYPE));
5612 /* Allocate buffer of that many longwords. */
8d749320 5613 buffer = XALLOCAVEC (PTRACE_XFER_TYPE, count);
4934b29e 5614
da6d8c04 5615 /* Read all the longwords */
4934b29e 5616 errno = 0;
da6d8c04
DJ
5617 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
5618 {
14ce3065
DE
5619 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5620 about coercing an 8 byte integer to a 4 byte pointer. */
5621 buffer[i] = ptrace (PTRACE_PEEKTEXT, pid,
b8e1b30e
LM
5622 (PTRACE_TYPE_ARG3) (uintptr_t) addr,
5623 (PTRACE_TYPE_ARG4) 0);
c3e735a6 5624 if (errno)
4934b29e 5625 break;
da6d8c04 5626 }
4934b29e 5627 ret = errno;
da6d8c04
DJ
5628
5629 /* Copy appropriate bytes out of the buffer. */
8d409d16
MR
5630 if (i > 0)
5631 {
5632 i *= sizeof (PTRACE_XFER_TYPE);
5633 i -= memaddr & (sizeof (PTRACE_XFER_TYPE) - 1);
5634 memcpy (myaddr,
5635 (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
5636 i < len ? i : len);
5637 }
c3e735a6 5638
4934b29e 5639 return ret;
da6d8c04
DJ
5640}
5641
93ae6fdc
PA
5642/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
5643 memory at MEMADDR. On failure (cannot write to the inferior)
f0ae6fc3 5644 returns the value of errno. Always succeeds if LEN is zero. */
da6d8c04 5645
ce3a066d 5646static int
f450004a 5647linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
da6d8c04
DJ
5648{
5649 register int i;
5650 /* Round starting address down to longword boundary. */
5651 register CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_XFER_TYPE);
5652 /* Round ending address up; get number of longwords that makes. */
5653 register int count
493e2a69
MS
5654 = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
5655 / sizeof (PTRACE_XFER_TYPE);
5656
da6d8c04 5657 /* Allocate buffer of that many longwords. */
8d749320 5658 register PTRACE_XFER_TYPE *buffer = XALLOCAVEC (PTRACE_XFER_TYPE, count);
493e2a69 5659
0bfdf32f 5660 int pid = lwpid_of (current_thread);
da6d8c04 5661
f0ae6fc3
PA
5662 if (len == 0)
5663 {
5664 /* Zero length write always succeeds. */
5665 return 0;
5666 }
5667
0d62e5e8
DJ
5668 if (debug_threads)
5669 {
58d6951d 5670 /* Dump up to four bytes. */
bf47e248
PA
5671 char str[4 * 2 + 1];
5672 char *p = str;
5673 int dump = len < 4 ? len : 4;
5674
5675 for (i = 0; i < dump; i++)
5676 {
5677 sprintf (p, "%02x", myaddr[i]);
5678 p += 2;
5679 }
5680 *p = '\0';
5681
5682 debug_printf ("Writing %s to 0x%08lx in process %d\n",
5683 str, (long) memaddr, pid);
0d62e5e8
DJ
5684 }
5685
da6d8c04
DJ
5686 /* Fill start and end extra bytes of buffer with existing memory data. */
5687
93ae6fdc 5688 errno = 0;
14ce3065
DE
5689 /* Coerce the 3rd arg to a uintptr_t first to avoid potential gcc warning
5690 about coercing an 8 byte integer to a 4 byte pointer. */
5691 buffer[0] = ptrace (PTRACE_PEEKTEXT, pid,
b8e1b30e
LM
5692 (PTRACE_TYPE_ARG3) (uintptr_t) addr,
5693 (PTRACE_TYPE_ARG4) 0);
93ae6fdc
PA
5694 if (errno)
5695 return errno;
da6d8c04
DJ
5696
5697 if (count > 1)
5698 {
93ae6fdc 5699 errno = 0;
da6d8c04 5700 buffer[count - 1]
95954743 5701 = ptrace (PTRACE_PEEKTEXT, pid,
14ce3065
DE
5702 /* Coerce to a uintptr_t first to avoid potential gcc warning
5703 about coercing an 8 byte integer to a 4 byte pointer. */
b8e1b30e 5704 (PTRACE_TYPE_ARG3) (uintptr_t) (addr + (count - 1)
14ce3065 5705 * sizeof (PTRACE_XFER_TYPE)),
b8e1b30e 5706 (PTRACE_TYPE_ARG4) 0);
93ae6fdc
PA
5707 if (errno)
5708 return errno;
da6d8c04
DJ
5709 }
5710
93ae6fdc 5711 /* Copy data to be written over corresponding part of buffer. */
da6d8c04 5712
493e2a69
MS
5713 memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
5714 myaddr, len);
da6d8c04
DJ
5715
5716 /* Write the entire buffer. */
5717
5718 for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
5719 {
5720 errno = 0;
14ce3065
DE
5721 ptrace (PTRACE_POKETEXT, pid,
5722 /* Coerce to a uintptr_t first to avoid potential gcc warning
5723 about coercing an 8 byte integer to a 4 byte pointer. */
b8e1b30e
LM
5724 (PTRACE_TYPE_ARG3) (uintptr_t) addr,
5725 (PTRACE_TYPE_ARG4) buffer[i]);
da6d8c04
DJ
5726 if (errno)
5727 return errno;
5728 }
5729
5730 return 0;
5731}
2f2893d9
DJ
5732
5733static void
5734linux_look_up_symbols (void)
5735{
0d62e5e8 5736#ifdef USE_THREAD_DB
95954743
PA
5737 struct process_info *proc = current_process ();
5738
fe978cb0 5739 if (proc->priv->thread_db != NULL)
0d62e5e8
DJ
5740 return;
5741
9b4c5f87 5742 thread_db_init ();
0d62e5e8
DJ
5743#endif
5744}
5745
e5379b03 5746static void
ef57601b 5747linux_request_interrupt (void)
e5379b03 5748{
a1928bad 5749 extern unsigned long signal_pid;
e5379b03 5750
78708b7c
PA
5751 /* Send a SIGINT to the process group. This acts just like the user
5752 typed a ^C on the controlling terminal. */
5753 kill (-signal_pid, SIGINT);
e5379b03
DJ
5754}
5755
aa691b87
RM
5756/* Copy LEN bytes from inferior's auxiliary vector starting at OFFSET
5757 to debugger memory starting at MYADDR. */
5758
5759static int
f450004a 5760linux_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int len)
aa691b87
RM
5761{
5762 char filename[PATH_MAX];
5763 int fd, n;
0bfdf32f 5764 int pid = lwpid_of (current_thread);
aa691b87 5765
6cebaf6e 5766 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
aa691b87
RM
5767
5768 fd = open (filename, O_RDONLY);
5769 if (fd < 0)
5770 return -1;
5771
5772 if (offset != (CORE_ADDR) 0
5773 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
5774 n = -1;
5775 else
5776 n = read (fd, myaddr, len);
5777
5778 close (fd);
5779
5780 return n;
5781}
5782
d993e290
PA
5783/* These breakpoint and watchpoint related wrapper functions simply
5784 pass on the function call if the target has registered a
5785 corresponding function. */
e013ee27
OF
5786
5787static int
802e8e6d
PA
5788linux_supports_z_point_type (char z_type)
5789{
5790 return (the_low_target.supports_z_point_type != NULL
5791 && the_low_target.supports_z_point_type (z_type));
5792}
5793
5794static int
5795linux_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
5796 int size, struct raw_breakpoint *bp)
e013ee27 5797{
c8f4bfdd
YQ
5798 if (type == raw_bkpt_type_sw)
5799 return insert_memory_breakpoint (bp);
5800 else if (the_low_target.insert_point != NULL)
802e8e6d 5801 return the_low_target.insert_point (type, addr, size, bp);
e013ee27
OF
5802 else
5803 /* Unsupported (see target.h). */
5804 return 1;
5805}
5806
5807static int
802e8e6d
PA
5808linux_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
5809 int size, struct raw_breakpoint *bp)
e013ee27 5810{
c8f4bfdd
YQ
5811 if (type == raw_bkpt_type_sw)
5812 return remove_memory_breakpoint (bp);
5813 else if (the_low_target.remove_point != NULL)
802e8e6d 5814 return the_low_target.remove_point (type, addr, size, bp);
e013ee27
OF
5815 else
5816 /* Unsupported (see target.h). */
5817 return 1;
5818}
5819
3e572f71
PA
5820/* Implement the to_stopped_by_sw_breakpoint target_ops
5821 method. */
5822
5823static int
5824linux_stopped_by_sw_breakpoint (void)
5825{
5826 struct lwp_info *lwp = get_thread_lwp (current_thread);
5827
5828 return (lwp->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT);
5829}
5830
5831/* Implement the to_supports_stopped_by_sw_breakpoint target_ops
5832 method. */
5833
5834static int
5835linux_supports_stopped_by_sw_breakpoint (void)
5836{
5837 return USE_SIGTRAP_SIGINFO;
5838}
5839
5840/* Implement the to_stopped_by_hw_breakpoint target_ops
5841 method. */
5842
5843static int
5844linux_stopped_by_hw_breakpoint (void)
5845{
5846 struct lwp_info *lwp = get_thread_lwp (current_thread);
5847
5848 return (lwp->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT);
5849}
5850
5851/* Implement the to_supports_stopped_by_hw_breakpoint target_ops
5852 method. */
5853
5854static int
5855linux_supports_stopped_by_hw_breakpoint (void)
5856{
5857 return USE_SIGTRAP_SIGINFO;
5858}
5859
70b90b91 5860/* Implement the supports_hardware_single_step target_ops method. */
45614f15
YQ
5861
5862static int
70b90b91 5863linux_supports_hardware_single_step (void)
45614f15 5864{
45614f15
YQ
5865 return can_hardware_single_step ();
5866}
5867
7d00775e
AT
5868static int
5869linux_supports_software_single_step (void)
5870{
5871 return can_software_single_step ();
5872}
5873
e013ee27
OF
5874static int
5875linux_stopped_by_watchpoint (void)
5876{
0bfdf32f 5877 struct lwp_info *lwp = get_thread_lwp (current_thread);
c3adc08c 5878
15c66dd6 5879 return lwp->stop_reason == TARGET_STOPPED_BY_WATCHPOINT;
e013ee27
OF
5880}
5881
5882static CORE_ADDR
5883linux_stopped_data_address (void)
5884{
0bfdf32f 5885 struct lwp_info *lwp = get_thread_lwp (current_thread);
c3adc08c
PA
5886
5887 return lwp->stopped_data_address;
e013ee27
OF
5888}
5889
db0dfaa0
LM
5890#if defined(__UCLIBC__) && defined(HAS_NOMMU) \
5891 && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
5892 && defined(PT_TEXT_END_ADDR)
5893
5894/* This is only used for targets that define PT_TEXT_ADDR,
5895 PT_DATA_ADDR and PT_TEXT_END_ADDR. If those are not defined, supposedly
5896 the target has different ways of acquiring this information, like
5897 loadmaps. */
52fb6437
NS
5898
5899/* Under uClinux, programs are loaded at non-zero offsets, which we need
5900 to tell gdb about. */
5901
5902static int
5903linux_read_offsets (CORE_ADDR *text_p, CORE_ADDR *data_p)
5904{
52fb6437 5905 unsigned long text, text_end, data;
62828379 5906 int pid = lwpid_of (current_thread);
52fb6437
NS
5907
5908 errno = 0;
5909
b8e1b30e
LM
5910 text = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_TEXT_ADDR,
5911 (PTRACE_TYPE_ARG4) 0);
5912 text_end = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_TEXT_END_ADDR,
5913 (PTRACE_TYPE_ARG4) 0);
5914 data = ptrace (PTRACE_PEEKUSER, pid, (PTRACE_TYPE_ARG3) PT_DATA_ADDR,
5915 (PTRACE_TYPE_ARG4) 0);
52fb6437
NS
5916
5917 if (errno == 0)
5918 {
5919 /* Both text and data offsets produced at compile-time (and so
1b3f6016
PA
5920 used by gdb) are relative to the beginning of the program,
5921 with the data segment immediately following the text segment.
5922 However, the actual runtime layout in memory may put the data
5923 somewhere else, so when we send gdb a data base-address, we
5924 use the real data base address and subtract the compile-time
5925 data base-address from it (which is just the length of the
5926 text segment). BSS immediately follows data in both
5927 cases. */
52fb6437
NS
5928 *text_p = text;
5929 *data_p = data - (text_end - text);
1b3f6016 5930
52fb6437
NS
5931 return 1;
5932 }
52fb6437
NS
5933 return 0;
5934}
5935#endif
5936
07e059b5
VP
5937static int
5938linux_qxfer_osdata (const char *annex,
1b3f6016
PA
5939 unsigned char *readbuf, unsigned const char *writebuf,
5940 CORE_ADDR offset, int len)
07e059b5 5941{
d26e3629 5942 return linux_common_xfer_osdata (annex, readbuf, offset, len);
07e059b5
VP
5943}
5944
d0722149
DE
5945/* Convert a native/host siginfo object, into/from the siginfo in the
5946 layout of the inferiors' architecture. */
5947
5948static void
8adce034 5949siginfo_fixup (siginfo_t *siginfo, gdb_byte *inf_siginfo, int direction)
d0722149
DE
5950{
5951 int done = 0;
5952
5953 if (the_low_target.siginfo_fixup != NULL)
5954 done = the_low_target.siginfo_fixup (siginfo, inf_siginfo, direction);
5955
5956 /* If there was no callback, or the callback didn't do anything,
5957 then just do a straight memcpy. */
5958 if (!done)
5959 {
5960 if (direction == 1)
a5362b9a 5961 memcpy (siginfo, inf_siginfo, sizeof (siginfo_t));
d0722149 5962 else
a5362b9a 5963 memcpy (inf_siginfo, siginfo, sizeof (siginfo_t));
d0722149
DE
5964 }
5965}
5966
4aa995e1
PA
5967static int
5968linux_xfer_siginfo (const char *annex, unsigned char *readbuf,
5969 unsigned const char *writebuf, CORE_ADDR offset, int len)
5970{
d0722149 5971 int pid;
a5362b9a 5972 siginfo_t siginfo;
8adce034 5973 gdb_byte inf_siginfo[sizeof (siginfo_t)];
4aa995e1 5974
0bfdf32f 5975 if (current_thread == NULL)
4aa995e1
PA
5976 return -1;
5977
0bfdf32f 5978 pid = lwpid_of (current_thread);
4aa995e1
PA
5979
5980 if (debug_threads)
87ce2a04
DE
5981 debug_printf ("%s siginfo for lwp %d.\n",
5982 readbuf != NULL ? "Reading" : "Writing",
5983 pid);
4aa995e1 5984
0adea5f7 5985 if (offset >= sizeof (siginfo))
4aa995e1
PA
5986 return -1;
5987
b8e1b30e 5988 if (ptrace (PTRACE_GETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo) != 0)
4aa995e1
PA
5989 return -1;
5990
d0722149
DE
5991 /* When GDBSERVER is built as a 64-bit application, ptrace writes into
5992 SIGINFO an object with 64-bit layout. Since debugging a 32-bit
5993 inferior with a 64-bit GDBSERVER should look the same as debugging it
5994 with a 32-bit GDBSERVER, we need to convert it. */
5995 siginfo_fixup (&siginfo, inf_siginfo, 0);
5996
4aa995e1
PA
5997 if (offset + len > sizeof (siginfo))
5998 len = sizeof (siginfo) - offset;
5999
6000 if (readbuf != NULL)
d0722149 6001 memcpy (readbuf, inf_siginfo + offset, len);
4aa995e1
PA
6002 else
6003 {
d0722149
DE
6004 memcpy (inf_siginfo + offset, writebuf, len);
6005
6006 /* Convert back to ptrace layout before flushing it out. */
6007 siginfo_fixup (&siginfo, inf_siginfo, 1);
6008
b8e1b30e 6009 if (ptrace (PTRACE_SETSIGINFO, pid, (PTRACE_TYPE_ARG3) 0, &siginfo) != 0)
4aa995e1
PA
6010 return -1;
6011 }
6012
6013 return len;
6014}
6015
bd99dc85
PA
6016/* SIGCHLD handler that serves two purposes: In non-stop/async mode,
6017 so we notice when children change state; as the handler for the
6018 sigsuspend in my_waitpid. */
6019
6020static void
6021sigchld_handler (int signo)
6022{
6023 int old_errno = errno;
6024
6025 if (debug_threads)
e581f2b4
PA
6026 {
6027 do
6028 {
6029 /* fprintf is not async-signal-safe, so call write
6030 directly. */
6031 if (write (2, "sigchld_handler\n",
6032 sizeof ("sigchld_handler\n") - 1) < 0)
6033 break; /* just ignore */
6034 } while (0);
6035 }
bd99dc85
PA
6036
6037 if (target_is_async_p ())
6038 async_file_mark (); /* trigger a linux_wait */
6039
6040 errno = old_errno;
6041}
6042
6043static int
6044linux_supports_non_stop (void)
6045{
6046 return 1;
6047}
6048
6049static int
6050linux_async (int enable)
6051{
7089dca4 6052 int previous = target_is_async_p ();
bd99dc85 6053
8336d594 6054 if (debug_threads)
87ce2a04
DE
6055 debug_printf ("linux_async (%d), previous=%d\n",
6056 enable, previous);
8336d594 6057
bd99dc85
PA
6058 if (previous != enable)
6059 {
6060 sigset_t mask;
6061 sigemptyset (&mask);
6062 sigaddset (&mask, SIGCHLD);
6063
6064 sigprocmask (SIG_BLOCK, &mask, NULL);
6065
6066 if (enable)
6067 {
6068 if (pipe (linux_event_pipe) == -1)
aa96c426
GB
6069 {
6070 linux_event_pipe[0] = -1;
6071 linux_event_pipe[1] = -1;
6072 sigprocmask (SIG_UNBLOCK, &mask, NULL);
6073
6074 warning ("creating event pipe failed.");
6075 return previous;
6076 }
bd99dc85
PA
6077
6078 fcntl (linux_event_pipe[0], F_SETFL, O_NONBLOCK);
6079 fcntl (linux_event_pipe[1], F_SETFL, O_NONBLOCK);
6080
6081 /* Register the event loop handler. */
6082 add_file_handler (linux_event_pipe[0],
6083 handle_target_event, NULL);
6084
6085 /* Always trigger a linux_wait. */
6086 async_file_mark ();
6087 }
6088 else
6089 {
6090 delete_file_handler (linux_event_pipe[0]);
6091
6092 close (linux_event_pipe[0]);
6093 close (linux_event_pipe[1]);
6094 linux_event_pipe[0] = -1;
6095 linux_event_pipe[1] = -1;
6096 }
6097
6098 sigprocmask (SIG_UNBLOCK, &mask, NULL);
6099 }
6100
6101 return previous;
6102}
6103
6104static int
6105linux_start_non_stop (int nonstop)
6106{
6107 /* Register or unregister from event-loop accordingly. */
6108 linux_async (nonstop);
aa96c426
GB
6109
6110 if (target_is_async_p () != (nonstop != 0))
6111 return -1;
6112
bd99dc85
PA
6113 return 0;
6114}
6115
cf8fd78b
PA
6116static int
6117linux_supports_multi_process (void)
6118{
6119 return 1;
6120}
6121
89245bc0
DB
6122/* Check if fork events are supported. */
6123
6124static int
6125linux_supports_fork_events (void)
6126{
6127 return linux_supports_tracefork ();
6128}
6129
6130/* Check if vfork events are supported. */
6131
6132static int
6133linux_supports_vfork_events (void)
6134{
6135 return linux_supports_tracefork ();
6136}
6137
94585166
DB
6138/* Check if exec events are supported. */
6139
6140static int
6141linux_supports_exec_events (void)
6142{
6143 return linux_supports_traceexec ();
6144}
6145
de0d863e
DB
6146/* Callback for 'find_inferior'. Set the (possibly changed) ptrace
6147 options for the specified lwp. */
6148
6149static int
6150reset_lwp_ptrace_options_callback (struct inferior_list_entry *entry,
6151 void *args)
6152{
6153 struct thread_info *thread = (struct thread_info *) entry;
6154 struct lwp_info *lwp = get_thread_lwp (thread);
6155
6156 if (!lwp->stopped)
6157 {
6158 /* Stop the lwp so we can modify its ptrace options. */
6159 lwp->must_set_ptrace_flags = 1;
6160 linux_stop_lwp (lwp);
6161 }
6162 else
6163 {
6164 /* Already stopped; go ahead and set the ptrace options. */
6165 struct process_info *proc = find_process_pid (pid_of (thread));
6166 int options = linux_low_ptrace_options (proc->attached);
6167
6168 linux_enable_event_reporting (lwpid_of (thread), options);
6169 lwp->must_set_ptrace_flags = 0;
6170 }
6171
6172 return 0;
6173}
6174
6175/* Target hook for 'handle_new_gdb_connection'. Causes a reset of the
6176 ptrace flags for all inferiors. This is in case the new GDB connection
6177 doesn't support the same set of events that the previous one did. */
6178
6179static void
6180linux_handle_new_gdb_connection (void)
6181{
6182 pid_t pid;
6183
6184 /* Request that all the lwps reset their ptrace options. */
6185 find_inferior (&all_threads, reset_lwp_ptrace_options_callback , &pid);
6186}
6187
03583c20
UW
6188static int
6189linux_supports_disable_randomization (void)
6190{
6191#ifdef HAVE_PERSONALITY
6192 return 1;
6193#else
6194 return 0;
6195#endif
6196}
efcbbd14 6197
d1feda86
YQ
6198static int
6199linux_supports_agent (void)
6200{
6201 return 1;
6202}
6203
c2d6af84
PA
6204static int
6205linux_supports_range_stepping (void)
6206{
6207 if (*the_low_target.supports_range_stepping == NULL)
6208 return 0;
6209
6210 return (*the_low_target.supports_range_stepping) ();
6211}
6212
efcbbd14
UW
6213/* Enumerate spufs IDs for process PID. */
6214static int
6215spu_enumerate_spu_ids (long pid, unsigned char *buf, CORE_ADDR offset, int len)
6216{
6217 int pos = 0;
6218 int written = 0;
6219 char path[128];
6220 DIR *dir;
6221 struct dirent *entry;
6222
6223 sprintf (path, "/proc/%ld/fd", pid);
6224 dir = opendir (path);
6225 if (!dir)
6226 return -1;
6227
6228 rewinddir (dir);
6229 while ((entry = readdir (dir)) != NULL)
6230 {
6231 struct stat st;
6232 struct statfs stfs;
6233 int fd;
6234
6235 fd = atoi (entry->d_name);
6236 if (!fd)
6237 continue;
6238
6239 sprintf (path, "/proc/%ld/fd/%d", pid, fd);
6240 if (stat (path, &st) != 0)
6241 continue;
6242 if (!S_ISDIR (st.st_mode))
6243 continue;
6244
6245 if (statfs (path, &stfs) != 0)
6246 continue;
6247 if (stfs.f_type != SPUFS_MAGIC)
6248 continue;
6249
6250 if (pos >= offset && pos + 4 <= offset + len)
6251 {
6252 *(unsigned int *)(buf + pos - offset) = fd;
6253 written += 4;
6254 }
6255 pos += 4;
6256 }
6257
6258 closedir (dir);
6259 return written;
6260}
6261
6262/* Implements the to_xfer_partial interface for the TARGET_OBJECT_SPU
6263 object type, using the /proc file system. */
6264static int
6265linux_qxfer_spu (const char *annex, unsigned char *readbuf,
6266 unsigned const char *writebuf,
6267 CORE_ADDR offset, int len)
6268{
0bfdf32f 6269 long pid = lwpid_of (current_thread);
efcbbd14
UW
6270 char buf[128];
6271 int fd = 0;
6272 int ret = 0;
6273
6274 if (!writebuf && !readbuf)
6275 return -1;
6276
6277 if (!*annex)
6278 {
6279 if (!readbuf)
6280 return -1;
6281 else
6282 return spu_enumerate_spu_ids (pid, readbuf, offset, len);
6283 }
6284
6285 sprintf (buf, "/proc/%ld/fd/%s", pid, annex);
6286 fd = open (buf, writebuf? O_WRONLY : O_RDONLY);
6287 if (fd <= 0)
6288 return -1;
6289
6290 if (offset != 0
6291 && lseek (fd, (off_t) offset, SEEK_SET) != (off_t) offset)
6292 {
6293 close (fd);
6294 return 0;
6295 }
6296
6297 if (writebuf)
6298 ret = write (fd, writebuf, (size_t) len);
6299 else
6300 ret = read (fd, readbuf, (size_t) len);
6301
6302 close (fd);
6303 return ret;
6304}
6305
723b724b 6306#if defined PT_GETDSBT || defined PTRACE_GETFDPIC
78d85199
YQ
6307struct target_loadseg
6308{
6309 /* Core address to which the segment is mapped. */
6310 Elf32_Addr addr;
6311 /* VMA recorded in the program header. */
6312 Elf32_Addr p_vaddr;
6313 /* Size of this segment in memory. */
6314 Elf32_Word p_memsz;
6315};
6316
723b724b 6317# if defined PT_GETDSBT
78d85199
YQ
6318struct target_loadmap
6319{
6320 /* Protocol version number, must be zero. */
6321 Elf32_Word version;
6322 /* Pointer to the DSBT table, its size, and the DSBT index. */
6323 unsigned *dsbt_table;
6324 unsigned dsbt_size, dsbt_index;
6325 /* Number of segments in this map. */
6326 Elf32_Word nsegs;
6327 /* The actual memory map. */
6328 struct target_loadseg segs[/*nsegs*/];
6329};
723b724b
MF
6330# define LINUX_LOADMAP PT_GETDSBT
6331# define LINUX_LOADMAP_EXEC PTRACE_GETDSBT_EXEC
6332# define LINUX_LOADMAP_INTERP PTRACE_GETDSBT_INTERP
6333# else
6334struct target_loadmap
6335{
6336 /* Protocol version number, must be zero. */
6337 Elf32_Half version;
6338 /* Number of segments in this map. */
6339 Elf32_Half nsegs;
6340 /* The actual memory map. */
6341 struct target_loadseg segs[/*nsegs*/];
6342};
6343# define LINUX_LOADMAP PTRACE_GETFDPIC
6344# define LINUX_LOADMAP_EXEC PTRACE_GETFDPIC_EXEC
6345# define LINUX_LOADMAP_INTERP PTRACE_GETFDPIC_INTERP
6346# endif
78d85199 6347
78d85199
YQ
6348static int
6349linux_read_loadmap (const char *annex, CORE_ADDR offset,
6350 unsigned char *myaddr, unsigned int len)
6351{
0bfdf32f 6352 int pid = lwpid_of (current_thread);
78d85199
YQ
6353 int addr = -1;
6354 struct target_loadmap *data = NULL;
6355 unsigned int actual_length, copy_length;
6356
6357 if (strcmp (annex, "exec") == 0)
723b724b 6358 addr = (int) LINUX_LOADMAP_EXEC;
78d85199 6359 else if (strcmp (annex, "interp") == 0)
723b724b 6360 addr = (int) LINUX_LOADMAP_INTERP;
78d85199
YQ
6361 else
6362 return -1;
6363
723b724b 6364 if (ptrace (LINUX_LOADMAP, pid, addr, &data) != 0)
78d85199
YQ
6365 return -1;
6366
6367 if (data == NULL)
6368 return -1;
6369
6370 actual_length = sizeof (struct target_loadmap)
6371 + sizeof (struct target_loadseg) * data->nsegs;
6372
6373 if (offset < 0 || offset > actual_length)
6374 return -1;
6375
6376 copy_length = actual_length - offset < len ? actual_length - offset : len;
6377 memcpy (myaddr, (char *) data + offset, copy_length);
6378 return copy_length;
6379}
723b724b
MF
6380#else
6381# define linux_read_loadmap NULL
6382#endif /* defined PT_GETDSBT || defined PTRACE_GETFDPIC */
78d85199 6383
1570b33e 6384static void
06e03fff 6385linux_process_qsupported (char **features, int count)
1570b33e
L
6386{
6387 if (the_low_target.process_qsupported != NULL)
06e03fff 6388 the_low_target.process_qsupported (features, count);
1570b33e
L
6389}
6390
82075af2
JS
6391static int
6392linux_supports_catch_syscall (void)
6393{
6394 return (the_low_target.get_syscall_trapinfo != NULL
6395 && linux_supports_tracesysgood ());
6396}
6397
ae91f625
MK
6398static int
6399linux_get_ipa_tdesc_idx (void)
6400{
6401 if (the_low_target.get_ipa_tdesc_idx == NULL)
6402 return 0;
6403
6404 return (*the_low_target.get_ipa_tdesc_idx) ();
6405}
6406
219f2f23
PA
6407static int
6408linux_supports_tracepoints (void)
6409{
6410 if (*the_low_target.supports_tracepoints == NULL)
6411 return 0;
6412
6413 return (*the_low_target.supports_tracepoints) ();
6414}
6415
6416static CORE_ADDR
6417linux_read_pc (struct regcache *regcache)
6418{
6419 if (the_low_target.get_pc == NULL)
6420 return 0;
6421
6422 return (*the_low_target.get_pc) (regcache);
6423}
6424
6425static void
6426linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
6427{
6428 gdb_assert (the_low_target.set_pc != NULL);
6429
6430 (*the_low_target.set_pc) (regcache, pc);
6431}
6432
8336d594
PA
6433static int
6434linux_thread_stopped (struct thread_info *thread)
6435{
6436 return get_thread_lwp (thread)->stopped;
6437}
6438
6439/* This exposes stop-all-threads functionality to other modules. */
6440
6441static void
7984d532 6442linux_pause_all (int freeze)
8336d594 6443{
7984d532
PA
6444 stop_all_lwps (freeze, NULL);
6445}
6446
6447/* This exposes unstop-all-threads functionality to other gdbserver
6448 modules. */
6449
6450static void
6451linux_unpause_all (int unfreeze)
6452{
6453 unstop_all_lwps (unfreeze, NULL);
8336d594
PA
6454}
6455
90d74c30
PA
6456static int
6457linux_prepare_to_access_memory (void)
6458{
6459 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6460 running LWP. */
6461 if (non_stop)
6462 linux_pause_all (1);
6463 return 0;
6464}
6465
6466static void
0146f85b 6467linux_done_accessing_memory (void)
90d74c30
PA
6468{
6469 /* Neither ptrace nor /proc/PID/mem allow accessing memory through a
6470 running LWP. */
6471 if (non_stop)
6472 linux_unpause_all (1);
6473}
6474
fa593d66
PA
6475static int
6476linux_install_fast_tracepoint_jump_pad (CORE_ADDR tpoint, CORE_ADDR tpaddr,
6477 CORE_ADDR collector,
6478 CORE_ADDR lockaddr,
6479 ULONGEST orig_size,
6480 CORE_ADDR *jump_entry,
405f8e94
SS
6481 CORE_ADDR *trampoline,
6482 ULONGEST *trampoline_size,
fa593d66
PA
6483 unsigned char *jjump_pad_insn,
6484 ULONGEST *jjump_pad_insn_size,
6485 CORE_ADDR *adjusted_insn_addr,
405f8e94
SS
6486 CORE_ADDR *adjusted_insn_addr_end,
6487 char *err)
fa593d66
PA
6488{
6489 return (*the_low_target.install_fast_tracepoint_jump_pad)
6490 (tpoint, tpaddr, collector, lockaddr, orig_size,
405f8e94
SS
6491 jump_entry, trampoline, trampoline_size,
6492 jjump_pad_insn, jjump_pad_insn_size,
6493 adjusted_insn_addr, adjusted_insn_addr_end,
6494 err);
fa593d66
PA
6495}
6496
6a271cae
PA
6497static struct emit_ops *
6498linux_emit_ops (void)
6499{
6500 if (the_low_target.emit_ops != NULL)
6501 return (*the_low_target.emit_ops) ();
6502 else
6503 return NULL;
6504}
6505
405f8e94
SS
6506static int
6507linux_get_min_fast_tracepoint_insn_len (void)
6508{
6509 return (*the_low_target.get_min_fast_tracepoint_insn_len) ();
6510}
6511
2268b414
JK
6512/* Extract &phdr and num_phdr in the inferior. Return 0 on success. */
6513
6514static int
6515get_phdr_phnum_from_proc_auxv (const int pid, const int is_elf64,
6516 CORE_ADDR *phdr_memaddr, int *num_phdr)
6517{
6518 char filename[PATH_MAX];
6519 int fd;
6520 const int auxv_size = is_elf64
6521 ? sizeof (Elf64_auxv_t) : sizeof (Elf32_auxv_t);
6522 char buf[sizeof (Elf64_auxv_t)]; /* The larger of the two. */
6523
6524 xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid);
6525
6526 fd = open (filename, O_RDONLY);
6527 if (fd < 0)
6528 return 1;
6529
6530 *phdr_memaddr = 0;
6531 *num_phdr = 0;
6532 while (read (fd, buf, auxv_size) == auxv_size
6533 && (*phdr_memaddr == 0 || *num_phdr == 0))
6534 {
6535 if (is_elf64)
6536 {
6537 Elf64_auxv_t *const aux = (Elf64_auxv_t *) buf;
6538
6539 switch (aux->a_type)
6540 {
6541 case AT_PHDR:
6542 *phdr_memaddr = aux->a_un.a_val;
6543 break;
6544 case AT_PHNUM:
6545 *num_phdr = aux->a_un.a_val;
6546 break;
6547 }
6548 }
6549 else
6550 {
6551 Elf32_auxv_t *const aux = (Elf32_auxv_t *) buf;
6552
6553 switch (aux->a_type)
6554 {
6555 case AT_PHDR:
6556 *phdr_memaddr = aux->a_un.a_val;
6557 break;
6558 case AT_PHNUM:
6559 *num_phdr = aux->a_un.a_val;
6560 break;
6561 }
6562 }
6563 }
6564
6565 close (fd);
6566
6567 if (*phdr_memaddr == 0 || *num_phdr == 0)
6568 {
6569 warning ("Unexpected missing AT_PHDR and/or AT_PHNUM: "
6570 "phdr_memaddr = %ld, phdr_num = %d",
6571 (long) *phdr_memaddr, *num_phdr);
6572 return 2;
6573 }
6574
6575 return 0;
6576}
6577
6578/* Return &_DYNAMIC (via PT_DYNAMIC) in the inferior, or 0 if not present. */
6579
6580static CORE_ADDR
6581get_dynamic (const int pid, const int is_elf64)
6582{
6583 CORE_ADDR phdr_memaddr, relocation;
db1ff28b 6584 int num_phdr, i;
2268b414 6585 unsigned char *phdr_buf;
db1ff28b 6586 const int phdr_size = is_elf64 ? sizeof (Elf64_Phdr) : sizeof (Elf32_Phdr);
2268b414
JK
6587
6588 if (get_phdr_phnum_from_proc_auxv (pid, is_elf64, &phdr_memaddr, &num_phdr))
6589 return 0;
6590
6591 gdb_assert (num_phdr < 100); /* Basic sanity check. */
224c3ddb 6592 phdr_buf = (unsigned char *) alloca (num_phdr * phdr_size);
2268b414
JK
6593
6594 if (linux_read_memory (phdr_memaddr, phdr_buf, num_phdr * phdr_size))
6595 return 0;
6596
6597 /* Compute relocation: it is expected to be 0 for "regular" executables,
6598 non-zero for PIE ones. */
6599 relocation = -1;
db1ff28b
JK
6600 for (i = 0; relocation == -1 && i < num_phdr; i++)
6601 if (is_elf64)
6602 {
6603 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
6604
6605 if (p->p_type == PT_PHDR)
6606 relocation = phdr_memaddr - p->p_vaddr;
6607 }
6608 else
6609 {
6610 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
6611
6612 if (p->p_type == PT_PHDR)
6613 relocation = phdr_memaddr - p->p_vaddr;
6614 }
6615
2268b414
JK
6616 if (relocation == -1)
6617 {
e237a7e2
JK
6618 /* PT_PHDR is optional, but necessary for PIE in general. Fortunately
6619 any real world executables, including PIE executables, have always
6620 PT_PHDR present. PT_PHDR is not present in some shared libraries or
6621 in fpc (Free Pascal 2.4) binaries but neither of those have a need for
6622 or present DT_DEBUG anyway (fpc binaries are statically linked).
6623
6624 Therefore if there exists DT_DEBUG there is always also PT_PHDR.
6625
6626 GDB could find RELOCATION also from AT_ENTRY - e_entry. */
6627
2268b414
JK
6628 return 0;
6629 }
6630
db1ff28b
JK
6631 for (i = 0; i < num_phdr; i++)
6632 {
6633 if (is_elf64)
6634 {
6635 Elf64_Phdr *const p = (Elf64_Phdr *) (phdr_buf + i * phdr_size);
6636
6637 if (p->p_type == PT_DYNAMIC)
6638 return p->p_vaddr + relocation;
6639 }
6640 else
6641 {
6642 Elf32_Phdr *const p = (Elf32_Phdr *) (phdr_buf + i * phdr_size);
2268b414 6643
db1ff28b
JK
6644 if (p->p_type == PT_DYNAMIC)
6645 return p->p_vaddr + relocation;
6646 }
6647 }
2268b414
JK
6648
6649 return 0;
6650}
6651
6652/* Return &_r_debug in the inferior, or -1 if not present. Return value
367ba2c2
MR
6653 can be 0 if the inferior does not yet have the library list initialized.
6654 We look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of
6655 DT_DEBUG, although they sometimes contain an unused DT_DEBUG entry too. */
2268b414
JK
6656
6657static CORE_ADDR
6658get_r_debug (const int pid, const int is_elf64)
6659{
6660 CORE_ADDR dynamic_memaddr;
6661 const int dyn_size = is_elf64 ? sizeof (Elf64_Dyn) : sizeof (Elf32_Dyn);
6662 unsigned char buf[sizeof (Elf64_Dyn)]; /* The larger of the two. */
367ba2c2 6663 CORE_ADDR map = -1;
2268b414
JK
6664
6665 dynamic_memaddr = get_dynamic (pid, is_elf64);
6666 if (dynamic_memaddr == 0)
367ba2c2 6667 return map;
2268b414
JK
6668
6669 while (linux_read_memory (dynamic_memaddr, buf, dyn_size) == 0)
6670 {
6671 if (is_elf64)
6672 {
6673 Elf64_Dyn *const dyn = (Elf64_Dyn *) buf;
a738da3a 6674#if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
367ba2c2
MR
6675 union
6676 {
6677 Elf64_Xword map;
6678 unsigned char buf[sizeof (Elf64_Xword)];
6679 }
6680 rld_map;
a738da3a
MF
6681#endif
6682#ifdef DT_MIPS_RLD_MAP
367ba2c2
MR
6683 if (dyn->d_tag == DT_MIPS_RLD_MAP)
6684 {
6685 if (linux_read_memory (dyn->d_un.d_val,
6686 rld_map.buf, sizeof (rld_map.buf)) == 0)
6687 return rld_map.map;
6688 else
6689 break;
6690 }
75f62ce7 6691#endif /* DT_MIPS_RLD_MAP */
a738da3a
MF
6692#ifdef DT_MIPS_RLD_MAP_REL
6693 if (dyn->d_tag == DT_MIPS_RLD_MAP_REL)
6694 {
6695 if (linux_read_memory (dyn->d_un.d_val + dynamic_memaddr,
6696 rld_map.buf, sizeof (rld_map.buf)) == 0)
6697 return rld_map.map;
6698 else
6699 break;
6700 }
6701#endif /* DT_MIPS_RLD_MAP_REL */
2268b414 6702
367ba2c2
MR
6703 if (dyn->d_tag == DT_DEBUG && map == -1)
6704 map = dyn->d_un.d_val;
2268b414
JK
6705
6706 if (dyn->d_tag == DT_NULL)
6707 break;
6708 }
6709 else
6710 {
6711 Elf32_Dyn *const dyn = (Elf32_Dyn *) buf;
a738da3a 6712#if defined DT_MIPS_RLD_MAP || defined DT_MIPS_RLD_MAP_REL
367ba2c2
MR
6713 union
6714 {
6715 Elf32_Word map;
6716 unsigned char buf[sizeof (Elf32_Word)];
6717 }
6718 rld_map;
a738da3a
MF
6719#endif
6720#ifdef DT_MIPS_RLD_MAP
367ba2c2
MR
6721 if (dyn->d_tag == DT_MIPS_RLD_MAP)
6722 {
6723 if (linux_read_memory (dyn->d_un.d_val,
6724 rld_map.buf, sizeof (rld_map.buf)) == 0)
6725 return rld_map.map;
6726 else
6727 break;
6728 }
75f62ce7 6729#endif /* DT_MIPS_RLD_MAP */
a738da3a
MF
6730#ifdef DT_MIPS_RLD_MAP_REL
6731 if (dyn->d_tag == DT_MIPS_RLD_MAP_REL)
6732 {
6733 if (linux_read_memory (dyn->d_un.d_val + dynamic_memaddr,
6734 rld_map.buf, sizeof (rld_map.buf)) == 0)
6735 return rld_map.map;
6736 else
6737 break;
6738 }
6739#endif /* DT_MIPS_RLD_MAP_REL */
2268b414 6740
367ba2c2
MR
6741 if (dyn->d_tag == DT_DEBUG && map == -1)
6742 map = dyn->d_un.d_val;
2268b414
JK
6743
6744 if (dyn->d_tag == DT_NULL)
6745 break;
6746 }
6747
6748 dynamic_memaddr += dyn_size;
6749 }
6750
367ba2c2 6751 return map;
2268b414
JK
6752}
6753
6754/* Read one pointer from MEMADDR in the inferior. */
6755
6756static int
6757read_one_ptr (CORE_ADDR memaddr, CORE_ADDR *ptr, int ptr_size)
6758{
485f1ee4
PA
6759 int ret;
6760
6761 /* Go through a union so this works on either big or little endian
6762 hosts, when the inferior's pointer size is smaller than the size
6763 of CORE_ADDR. It is assumed the inferior's endianness is the
6764 same of the superior's. */
6765 union
6766 {
6767 CORE_ADDR core_addr;
6768 unsigned int ui;
6769 unsigned char uc;
6770 } addr;
6771
6772 ret = linux_read_memory (memaddr, &addr.uc, ptr_size);
6773 if (ret == 0)
6774 {
6775 if (ptr_size == sizeof (CORE_ADDR))
6776 *ptr = addr.core_addr;
6777 else if (ptr_size == sizeof (unsigned int))
6778 *ptr = addr.ui;
6779 else
6780 gdb_assert_not_reached ("unhandled pointer size");
6781 }
6782 return ret;
2268b414
JK
6783}
6784
6785struct link_map_offsets
6786 {
6787 /* Offset and size of r_debug.r_version. */
6788 int r_version_offset;
6789
6790 /* Offset and size of r_debug.r_map. */
6791 int r_map_offset;
6792
6793 /* Offset to l_addr field in struct link_map. */
6794 int l_addr_offset;
6795
6796 /* Offset to l_name field in struct link_map. */
6797 int l_name_offset;
6798
6799 /* Offset to l_ld field in struct link_map. */
6800 int l_ld_offset;
6801
6802 /* Offset to l_next field in struct link_map. */
6803 int l_next_offset;
6804
6805 /* Offset to l_prev field in struct link_map. */
6806 int l_prev_offset;
6807 };
6808
fb723180 6809/* Construct qXfer:libraries-svr4:read reply. */
2268b414
JK
6810
6811static int
6812linux_qxfer_libraries_svr4 (const char *annex, unsigned char *readbuf,
6813 unsigned const char *writebuf,
6814 CORE_ADDR offset, int len)
6815{
6816 char *document;
6817 unsigned document_len;
fe978cb0 6818 struct process_info_private *const priv = current_process ()->priv;
2268b414
JK
6819 char filename[PATH_MAX];
6820 int pid, is_elf64;
6821
6822 static const struct link_map_offsets lmo_32bit_offsets =
6823 {
6824 0, /* r_version offset. */
6825 4, /* r_debug.r_map offset. */
6826 0, /* l_addr offset in link_map. */
6827 4, /* l_name offset in link_map. */
6828 8, /* l_ld offset in link_map. */
6829 12, /* l_next offset in link_map. */
6830 16 /* l_prev offset in link_map. */
6831 };
6832
6833 static const struct link_map_offsets lmo_64bit_offsets =
6834 {
6835 0, /* r_version offset. */
6836 8, /* r_debug.r_map offset. */
6837 0, /* l_addr offset in link_map. */
6838 8, /* l_name offset in link_map. */
6839 16, /* l_ld offset in link_map. */
6840 24, /* l_next offset in link_map. */
6841 32 /* l_prev offset in link_map. */
6842 };
6843 const struct link_map_offsets *lmo;
214d508e 6844 unsigned int machine;
b1fbec62
GB
6845 int ptr_size;
6846 CORE_ADDR lm_addr = 0, lm_prev = 0;
6847 int allocated = 1024;
6848 char *p;
6849 CORE_ADDR l_name, l_addr, l_ld, l_next, l_prev;
6850 int header_done = 0;
2268b414
JK
6851
6852 if (writebuf != NULL)
6853 return -2;
6854 if (readbuf == NULL)
6855 return -1;
6856
0bfdf32f 6857 pid = lwpid_of (current_thread);
2268b414 6858 xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid);
214d508e 6859 is_elf64 = elf_64_file_p (filename, &machine);
2268b414 6860 lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets;
b1fbec62 6861 ptr_size = is_elf64 ? 8 : 4;
2268b414 6862
b1fbec62
GB
6863 while (annex[0] != '\0')
6864 {
6865 const char *sep;
6866 CORE_ADDR *addrp;
6867 int len;
2268b414 6868
b1fbec62
GB
6869 sep = strchr (annex, '=');
6870 if (sep == NULL)
6871 break;
0c5bf5a9 6872
b1fbec62 6873 len = sep - annex;
61012eef 6874 if (len == 5 && startswith (annex, "start"))
b1fbec62 6875 addrp = &lm_addr;
61012eef 6876 else if (len == 4 && startswith (annex, "prev"))
b1fbec62
GB
6877 addrp = &lm_prev;
6878 else
6879 {
6880 annex = strchr (sep, ';');
6881 if (annex == NULL)
6882 break;
6883 annex++;
6884 continue;
6885 }
6886
6887 annex = decode_address_to_semicolon (addrp, sep + 1);
2268b414 6888 }
b1fbec62
GB
6889
6890 if (lm_addr == 0)
2268b414 6891 {
b1fbec62
GB
6892 int r_version = 0;
6893
6894 if (priv->r_debug == 0)
6895 priv->r_debug = get_r_debug (pid, is_elf64);
6896
6897 /* We failed to find DT_DEBUG. Such situation will not change
6898 for this inferior - do not retry it. Report it to GDB as
6899 E01, see for the reasons at the GDB solib-svr4.c side. */
6900 if (priv->r_debug == (CORE_ADDR) -1)
6901 return -1;
6902
6903 if (priv->r_debug != 0)
2268b414 6904 {
b1fbec62
GB
6905 if (linux_read_memory (priv->r_debug + lmo->r_version_offset,
6906 (unsigned char *) &r_version,
6907 sizeof (r_version)) != 0
6908 || r_version != 1)
6909 {
6910 warning ("unexpected r_debug version %d", r_version);
6911 }
6912 else if (read_one_ptr (priv->r_debug + lmo->r_map_offset,
6913 &lm_addr, ptr_size) != 0)
6914 {
6915 warning ("unable to read r_map from 0x%lx",
6916 (long) priv->r_debug + lmo->r_map_offset);
6917 }
2268b414 6918 }
b1fbec62 6919 }
2268b414 6920
224c3ddb 6921 document = (char *) xmalloc (allocated);
b1fbec62
GB
6922 strcpy (document, "<library-list-svr4 version=\"1.0\"");
6923 p = document + strlen (document);
6924
6925 while (lm_addr
6926 && read_one_ptr (lm_addr + lmo->l_name_offset,
6927 &l_name, ptr_size) == 0
6928 && read_one_ptr (lm_addr + lmo->l_addr_offset,
6929 &l_addr, ptr_size) == 0
6930 && read_one_ptr (lm_addr + lmo->l_ld_offset,
6931 &l_ld, ptr_size) == 0
6932 && read_one_ptr (lm_addr + lmo->l_prev_offset,
6933 &l_prev, ptr_size) == 0
6934 && read_one_ptr (lm_addr + lmo->l_next_offset,
6935 &l_next, ptr_size) == 0)
6936 {
6937 unsigned char libname[PATH_MAX];
6938
6939 if (lm_prev != l_prev)
2268b414 6940 {
b1fbec62
GB
6941 warning ("Corrupted shared library list: 0x%lx != 0x%lx",
6942 (long) lm_prev, (long) l_prev);
6943 break;
2268b414
JK
6944 }
6945
d878444c
JK
6946 /* Ignore the first entry even if it has valid name as the first entry
6947 corresponds to the main executable. The first entry should not be
6948 skipped if the dynamic loader was loaded late by a static executable
6949 (see solib-svr4.c parameter ignore_first). But in such case the main
6950 executable does not have PT_DYNAMIC present and this function already
6951 exited above due to failed get_r_debug. */
6952 if (lm_prev == 0)
2268b414 6953 {
d878444c
JK
6954 sprintf (p, " main-lm=\"0x%lx\"", (unsigned long) lm_addr);
6955 p = p + strlen (p);
6956 }
6957 else
6958 {
6959 /* Not checking for error because reading may stop before
6960 we've got PATH_MAX worth of characters. */
6961 libname[0] = '\0';
6962 linux_read_memory (l_name, libname, sizeof (libname) - 1);
6963 libname[sizeof (libname) - 1] = '\0';
6964 if (libname[0] != '\0')
2268b414 6965 {
d878444c
JK
6966 /* 6x the size for xml_escape_text below. */
6967 size_t len = 6 * strlen ((char *) libname);
6968 char *name;
2268b414 6969
d878444c
JK
6970 if (!header_done)
6971 {
6972 /* Terminate `<library-list-svr4'. */
6973 *p++ = '>';
6974 header_done = 1;
6975 }
2268b414 6976
db1ff28b 6977 while (allocated < p - document + len + 200)
d878444c
JK
6978 {
6979 /* Expand to guarantee sufficient storage. */
6980 uintptr_t document_len = p - document;
2268b414 6981
224c3ddb 6982 document = (char *) xrealloc (document, 2 * allocated);
d878444c
JK
6983 allocated *= 2;
6984 p = document + document_len;
6985 }
6986
6987 name = xml_escape_text ((char *) libname);
6988 p += sprintf (p, "<library name=\"%s\" lm=\"0x%lx\" "
db1ff28b 6989 "l_addr=\"0x%lx\" l_ld=\"0x%lx\"/>",
d878444c
JK
6990 name, (unsigned long) lm_addr,
6991 (unsigned long) l_addr, (unsigned long) l_ld);
6992 free (name);
6993 }
0afae3cf 6994 }
b1fbec62
GB
6995
6996 lm_prev = lm_addr;
6997 lm_addr = l_next;
2268b414
JK
6998 }
6999
b1fbec62
GB
7000 if (!header_done)
7001 {
7002 /* Empty list; terminate `<library-list-svr4'. */
7003 strcpy (p, "/>");
7004 }
7005 else
7006 strcpy (p, "</library-list-svr4>");
7007
2268b414
JK
7008 document_len = strlen (document);
7009 if (offset < document_len)
7010 document_len -= offset;
7011 else
7012 document_len = 0;
7013 if (len > document_len)
7014 len = document_len;
7015
7016 memcpy (readbuf, document + offset, len);
7017 xfree (document);
7018
7019 return len;
7020}
7021
9accd112
MM
7022#ifdef HAVE_LINUX_BTRACE
7023
969c39fb 7024/* See to_disable_btrace target method. */
9accd112 7025
969c39fb
MM
7026static int
7027linux_low_disable_btrace (struct btrace_target_info *tinfo)
7028{
7029 enum btrace_error err;
7030
7031 err = linux_disable_btrace (tinfo);
7032 return (err == BTRACE_ERR_NONE ? 0 : -1);
7033}
7034
bc504a31 7035/* Encode an Intel Processor Trace configuration. */
b20a6524
MM
7036
7037static void
7038linux_low_encode_pt_config (struct buffer *buffer,
7039 const struct btrace_data_pt_config *config)
7040{
7041 buffer_grow_str (buffer, "<pt-config>\n");
7042
7043 switch (config->cpu.vendor)
7044 {
7045 case CV_INTEL:
7046 buffer_xml_printf (buffer, "<cpu vendor=\"GenuineIntel\" family=\"%u\" "
7047 "model=\"%u\" stepping=\"%u\"/>\n",
7048 config->cpu.family, config->cpu.model,
7049 config->cpu.stepping);
7050 break;
7051
7052 default:
7053 break;
7054 }
7055
7056 buffer_grow_str (buffer, "</pt-config>\n");
7057}
7058
7059/* Encode a raw buffer. */
7060
7061static void
7062linux_low_encode_raw (struct buffer *buffer, const gdb_byte *data,
7063 unsigned int size)
7064{
7065 if (size == 0)
7066 return;
7067
7068 /* We use hex encoding - see common/rsp-low.h. */
7069 buffer_grow_str (buffer, "<raw>\n");
7070
7071 while (size-- > 0)
7072 {
7073 char elem[2];
7074
7075 elem[0] = tohex ((*data >> 4) & 0xf);
7076 elem[1] = tohex (*data++ & 0xf);
7077
7078 buffer_grow (buffer, elem, 2);
7079 }
7080
7081 buffer_grow_str (buffer, "</raw>\n");
7082}
7083
969c39fb
MM
7084/* See to_read_btrace target method. */
7085
7086static int
9accd112 7087linux_low_read_btrace (struct btrace_target_info *tinfo, struct buffer *buffer,
add67df8 7088 enum btrace_read_type type)
9accd112 7089{
734b0e4b 7090 struct btrace_data btrace;
9accd112 7091 struct btrace_block *block;
969c39fb 7092 enum btrace_error err;
9accd112
MM
7093 int i;
7094
734b0e4b
MM
7095 btrace_data_init (&btrace);
7096
969c39fb
MM
7097 err = linux_read_btrace (&btrace, tinfo, type);
7098 if (err != BTRACE_ERR_NONE)
7099 {
7100 if (err == BTRACE_ERR_OVERFLOW)
7101 buffer_grow_str0 (buffer, "E.Overflow.");
7102 else
7103 buffer_grow_str0 (buffer, "E.Generic Error.");
7104
b20a6524 7105 goto err;
969c39fb 7106 }
9accd112 7107
734b0e4b
MM
7108 switch (btrace.format)
7109 {
7110 case BTRACE_FORMAT_NONE:
7111 buffer_grow_str0 (buffer, "E.No Trace.");
b20a6524 7112 goto err;
734b0e4b
MM
7113
7114 case BTRACE_FORMAT_BTS:
7115 buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
7116 buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
9accd112 7117
734b0e4b
MM
7118 for (i = 0;
7119 VEC_iterate (btrace_block_s, btrace.variant.bts.blocks, i, block);
7120 i++)
7121 buffer_xml_printf (buffer, "<block begin=\"0x%s\" end=\"0x%s\"/>\n",
7122 paddress (block->begin), paddress (block->end));
9accd112 7123
734b0e4b
MM
7124 buffer_grow_str0 (buffer, "</btrace>\n");
7125 break;
7126
b20a6524
MM
7127 case BTRACE_FORMAT_PT:
7128 buffer_grow_str (buffer, "<!DOCTYPE btrace SYSTEM \"btrace.dtd\">\n");
7129 buffer_grow_str (buffer, "<btrace version=\"1.0\">\n");
7130 buffer_grow_str (buffer, "<pt>\n");
7131
7132 linux_low_encode_pt_config (buffer, &btrace.variant.pt.config);
9accd112 7133
b20a6524
MM
7134 linux_low_encode_raw (buffer, btrace.variant.pt.data,
7135 btrace.variant.pt.size);
7136
7137 buffer_grow_str (buffer, "</pt>\n");
7138 buffer_grow_str0 (buffer, "</btrace>\n");
7139 break;
7140
7141 default:
7142 buffer_grow_str0 (buffer, "E.Unsupported Trace Format.");
7143 goto err;
734b0e4b 7144 }
969c39fb 7145
734b0e4b 7146 btrace_data_fini (&btrace);
969c39fb 7147 return 0;
b20a6524
MM
7148
7149err:
7150 btrace_data_fini (&btrace);
7151 return -1;
9accd112 7152}
f4abbc16
MM
7153
7154/* See to_btrace_conf target method. */
7155
7156static int
7157linux_low_btrace_conf (const struct btrace_target_info *tinfo,
7158 struct buffer *buffer)
7159{
7160 const struct btrace_config *conf;
7161
7162 buffer_grow_str (buffer, "<!DOCTYPE btrace-conf SYSTEM \"btrace-conf.dtd\">\n");
7163 buffer_grow_str (buffer, "<btrace-conf version=\"1.0\">\n");
7164
7165 conf = linux_btrace_conf (tinfo);
7166 if (conf != NULL)
7167 {
7168 switch (conf->format)
7169 {
7170 case BTRACE_FORMAT_NONE:
7171 break;
7172
7173 case BTRACE_FORMAT_BTS:
d33501a5
MM
7174 buffer_xml_printf (buffer, "<bts");
7175 buffer_xml_printf (buffer, " size=\"0x%x\"", conf->bts.size);
7176 buffer_xml_printf (buffer, " />\n");
f4abbc16 7177 break;
b20a6524
MM
7178
7179 case BTRACE_FORMAT_PT:
7180 buffer_xml_printf (buffer, "<pt");
7181 buffer_xml_printf (buffer, " size=\"0x%x\"", conf->pt.size);
7182 buffer_xml_printf (buffer, "/>\n");
7183 break;
f4abbc16
MM
7184 }
7185 }
7186
7187 buffer_grow_str0 (buffer, "</btrace-conf>\n");
7188 return 0;
7189}
9accd112
MM
7190#endif /* HAVE_LINUX_BTRACE */
7191
7b669087
GB
7192/* See nat/linux-nat.h. */
7193
7194ptid_t
7195current_lwp_ptid (void)
7196{
7197 return ptid_of (current_thread);
7198}
7199
dd373349
AT
7200/* Implementation of the target_ops method "breakpoint_kind_from_pc". */
7201
7202static int
7203linux_breakpoint_kind_from_pc (CORE_ADDR *pcptr)
7204{
7205 if (the_low_target.breakpoint_kind_from_pc != NULL)
7206 return (*the_low_target.breakpoint_kind_from_pc) (pcptr);
7207 else
1652a986 7208 return default_breakpoint_kind_from_pc (pcptr);
dd373349
AT
7209}
7210
7211/* Implementation of the target_ops method "sw_breakpoint_from_kind". */
7212
7213static const gdb_byte *
7214linux_sw_breakpoint_from_kind (int kind, int *size)
7215{
7216 gdb_assert (the_low_target.sw_breakpoint_from_kind != NULL);
7217
7218 return (*the_low_target.sw_breakpoint_from_kind) (kind, size);
7219}
7220
769ef81f
AT
7221/* Implementation of the target_ops method
7222 "breakpoint_kind_from_current_state". */
7223
7224static int
7225linux_breakpoint_kind_from_current_state (CORE_ADDR *pcptr)
7226{
7227 if (the_low_target.breakpoint_kind_from_current_state != NULL)
7228 return (*the_low_target.breakpoint_kind_from_current_state) (pcptr);
7229 else
7230 return linux_breakpoint_kind_from_pc (pcptr);
7231}
7232
276d4552
YQ
7233/* Default implementation of linux_target_ops method "set_pc" for
7234 32-bit pc register which is literally named "pc". */
7235
7236void
7237linux_set_pc_32bit (struct regcache *regcache, CORE_ADDR pc)
7238{
7239 uint32_t newpc = pc;
7240
7241 supply_register_by_name (regcache, "pc", &newpc);
7242}
7243
7244/* Default implementation of linux_target_ops method "get_pc" for
7245 32-bit pc register which is literally named "pc". */
7246
7247CORE_ADDR
7248linux_get_pc_32bit (struct regcache *regcache)
7249{
7250 uint32_t pc;
7251
7252 collect_register_by_name (regcache, "pc", &pc);
7253 if (debug_threads)
7254 debug_printf ("stop pc is 0x%" PRIx32 "\n", pc);
7255 return pc;
7256}
7257
6f69e520
YQ
7258/* Default implementation of linux_target_ops method "set_pc" for
7259 64-bit pc register which is literally named "pc". */
7260
7261void
7262linux_set_pc_64bit (struct regcache *regcache, CORE_ADDR pc)
7263{
7264 uint64_t newpc = pc;
7265
7266 supply_register_by_name (regcache, "pc", &newpc);
7267}
7268
7269/* Default implementation of linux_target_ops method "get_pc" for
7270 64-bit pc register which is literally named "pc". */
7271
7272CORE_ADDR
7273linux_get_pc_64bit (struct regcache *regcache)
7274{
7275 uint64_t pc;
7276
7277 collect_register_by_name (regcache, "pc", &pc);
7278 if (debug_threads)
7279 debug_printf ("stop pc is 0x%" PRIx64 "\n", pc);
7280 return pc;
7281}
7282
7283
ce3a066d
DJ
7284static struct target_ops linux_target_ops = {
7285 linux_create_inferior,
ece66d65 7286 linux_post_create_inferior,
ce3a066d
DJ
7287 linux_attach,
7288 linux_kill,
6ad8ae5c 7289 linux_detach,
8336d594 7290 linux_mourn,
444d6139 7291 linux_join,
ce3a066d
DJ
7292 linux_thread_alive,
7293 linux_resume,
7294 linux_wait,
7295 linux_fetch_registers,
7296 linux_store_registers,
90d74c30 7297 linux_prepare_to_access_memory,
0146f85b 7298 linux_done_accessing_memory,
ce3a066d
DJ
7299 linux_read_memory,
7300 linux_write_memory,
2f2893d9 7301 linux_look_up_symbols,
ef57601b 7302 linux_request_interrupt,
aa691b87 7303 linux_read_auxv,
802e8e6d 7304 linux_supports_z_point_type,
d993e290
PA
7305 linux_insert_point,
7306 linux_remove_point,
3e572f71
PA
7307 linux_stopped_by_sw_breakpoint,
7308 linux_supports_stopped_by_sw_breakpoint,
7309 linux_stopped_by_hw_breakpoint,
7310 linux_supports_stopped_by_hw_breakpoint,
70b90b91 7311 linux_supports_hardware_single_step,
e013ee27
OF
7312 linux_stopped_by_watchpoint,
7313 linux_stopped_data_address,
db0dfaa0
LM
7314#if defined(__UCLIBC__) && defined(HAS_NOMMU) \
7315 && defined(PT_TEXT_ADDR) && defined(PT_DATA_ADDR) \
7316 && defined(PT_TEXT_END_ADDR)
52fb6437 7317 linux_read_offsets,
dae5f5cf
DJ
7318#else
7319 NULL,
7320#endif
7321#ifdef USE_THREAD_DB
7322 thread_db_get_tls_address,
7323#else
7324 NULL,
52fb6437 7325#endif
efcbbd14 7326 linux_qxfer_spu,
59a016f0 7327 hostio_last_error_from_errno,
07e059b5 7328 linux_qxfer_osdata,
4aa995e1 7329 linux_xfer_siginfo,
bd99dc85
PA
7330 linux_supports_non_stop,
7331 linux_async,
7332 linux_start_non_stop,
cdbfd419 7333 linux_supports_multi_process,
89245bc0
DB
7334 linux_supports_fork_events,
7335 linux_supports_vfork_events,
94585166 7336 linux_supports_exec_events,
de0d863e 7337 linux_handle_new_gdb_connection,
cdbfd419 7338#ifdef USE_THREAD_DB
dc146f7c 7339 thread_db_handle_monitor_command,
cdbfd419 7340#else
dc146f7c 7341 NULL,
cdbfd419 7342#endif
d26e3629 7343 linux_common_core_of_thread,
78d85199 7344 linux_read_loadmap,
219f2f23
PA
7345 linux_process_qsupported,
7346 linux_supports_tracepoints,
7347 linux_read_pc,
8336d594
PA
7348 linux_write_pc,
7349 linux_thread_stopped,
7984d532 7350 NULL,
711e434b 7351 linux_pause_all,
7984d532 7352 linux_unpause_all,
fa593d66 7353 linux_stabilize_threads,
6a271cae 7354 linux_install_fast_tracepoint_jump_pad,
03583c20
UW
7355 linux_emit_ops,
7356 linux_supports_disable_randomization,
405f8e94 7357 linux_get_min_fast_tracepoint_insn_len,
2268b414 7358 linux_qxfer_libraries_svr4,
d1feda86 7359 linux_supports_agent,
9accd112
MM
7360#ifdef HAVE_LINUX_BTRACE
7361 linux_supports_btrace,
0568462b 7362 linux_enable_btrace,
969c39fb 7363 linux_low_disable_btrace,
9accd112 7364 linux_low_read_btrace,
f4abbc16 7365 linux_low_btrace_conf,
9accd112
MM
7366#else
7367 NULL,
7368 NULL,
7369 NULL,
7370 NULL,
f4abbc16 7371 NULL,
9accd112 7372#endif
c2d6af84 7373 linux_supports_range_stepping,
e57f1de3 7374 linux_proc_pid_to_exec_file,
14d2069a
GB
7375 linux_mntns_open_cloexec,
7376 linux_mntns_unlink,
7377 linux_mntns_readlink,
dd373349 7378 linux_breakpoint_kind_from_pc,
79efa585
SM
7379 linux_sw_breakpoint_from_kind,
7380 linux_proc_tid_get_name,
7d00775e 7381 linux_breakpoint_kind_from_current_state,
82075af2
JS
7382 linux_supports_software_single_step,
7383 linux_supports_catch_syscall,
ae91f625 7384 linux_get_ipa_tdesc_idx,
ce3a066d
DJ
7385};
7386
3aee8918
PA
7387#ifdef HAVE_LINUX_REGSETS
7388void
7389initialize_regsets_info (struct regsets_info *info)
7390{
7391 for (info->num_regsets = 0;
7392 info->regsets[info->num_regsets].size >= 0;
7393 info->num_regsets++)
7394 ;
3aee8918
PA
7395}
7396#endif
7397
da6d8c04
DJ
7398void
7399initialize_low (void)
7400{
bd99dc85 7401 struct sigaction sigchld_action;
dd373349 7402
bd99dc85 7403 memset (&sigchld_action, 0, sizeof (sigchld_action));
ce3a066d 7404 set_target_ops (&linux_target_ops);
dd373349 7405
aa7c7447 7406 linux_ptrace_init_warnings ();
bd99dc85
PA
7407
7408 sigchld_action.sa_handler = sigchld_handler;
7409 sigemptyset (&sigchld_action.sa_mask);
7410 sigchld_action.sa_flags = SA_RESTART;
7411 sigaction (SIGCHLD, &sigchld_action, NULL);
3aee8918
PA
7412
7413 initialize_low_arch ();
89245bc0
DB
7414
7415 linux_check_ptrace_features ();
da6d8c04 7416}