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