GDBserver

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