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