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