GDB (xrefs)
Loading...
Searching...
No Matches
linux-fork.c
Go to the documentation of this file.
1/* GNU/Linux native-dependent code for debugging multiple forks.
2
3 Copyright (C) 2005-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "arch-utils.h"
22#include "inferior.h"
23#include "infrun.h"
24#include "regcache.h"
25#include "gdbcmd.h"
26#include "infcall.h"
27#include "objfiles.h"
28#include "linux-fork.h"
29#include "linux-nat.h"
30#include "gdbthread.h"
31#include "source.h"
32
33#include "nat/gdb_ptrace.h"
34#include "gdbsupport/gdb_wait.h"
35#include <dirent.h>
36#include <ctype.h>
37
38#include <list>
39
40/* Fork list data structure: */
42{
43 explicit fork_info (pid_t pid)
44 : ptid (pid, pid)
45 {
46 }
47
49 {
50 /* Notes on step-resume breakpoints: since this is a concern for
51 threads, let's convince ourselves that it's not a concern for
52 forks. There are two ways for a fork_info to be created.
53 First, by the checkpoint command, in which case we're at a gdb
54 prompt and there can't be any step-resume breakpoint. Second,
55 by a fork in the user program, in which case we *may* have
56 stepped into the fork call, but regardless of whether we follow
57 the parent or the child, we will return to the same place and
58 the step-resume breakpoint, if any, will take care of itself as
59 usual. And unlike threads, we do not save a private copy of
60 the step-resume breakpoint -- so we're OK. */
61
62 if (savedregs)
63 delete savedregs;
64
65 xfree (filepos);
66 }
67
68 ptid_t ptid = null_ptid;
69 ptid_t parent_ptid = null_ptid;
70
71 /* Convenient handle (GDB fork id). */
72 int num = 0;
73
74 /* Convenient for info fork, saves having to actually switch
75 contexts. */
77
78 CORE_ADDR pc = 0;
79
80 /* Set of open file descriptors' offsets. */
81 off_t *filepos = nullptr;
82
83 int maxfd = 0;
84};
85
86static std::list<fork_info> fork_list;
88
89/* Fork list methods: */
90
91int
93{
94 return !fork_list.empty ();
95}
96
97/* Return the last fork in the list. */
98
99static struct fork_info *
101{
102 if (fork_list.empty ())
103 return NULL;
104
105 return &fork_list.back ();
106}
107
108/* Return true iff there's one fork in the list. */
109
110static bool
112{
113 return fork_list.size () == 1;
114}
115
116/* Add a new fork to the internal fork list. */
117
118void
120{
121 fork_list.emplace_back (pid);
122
123 if (one_fork_p ())
125
126 fork_info *fp = &fork_list.back ();
127 fp->num = ++highest_fork_num;
128}
129
130static void
132{
134
135 for (auto it = fork_list.begin (); it != fork_list.end (); ++it)
136 if (it->ptid == ptid)
137 {
138 fork_list.erase (it);
139
140 /* Special case: if there is now only one process in the list,
141 and if it is (hopefully!) the current inferior_ptid, then
142 remove it, leaving the list empty -- we're now down to the
143 default case of debugging a single process. */
144 if (one_fork_p () && fork_list.front ().ptid == inferior_ptid)
145 {
146 /* Last fork -- delete from list and handle as solo
147 process (should be a safe recursion). */
149 }
150 return;
151 }
152}
153
154/* Find a fork_info by matching PTID. */
155static struct fork_info *
157{
158 for (fork_info &fi : fork_list)
159 if (fi.ptid == ptid)
160 return &fi;
161
162 return NULL;
163}
164
165/* Find a fork_info by matching ID. */
166static struct fork_info *
168{
169 for (fork_info &fi : fork_list)
170 if (fi.num == num)
171 return &fi;
172
173 return NULL;
174}
175
176/* Find a fork_info by matching pid. */
177extern struct fork_info *
179{
180 for (fork_info &fi : fork_list)
181 if (pid == fi.ptid.pid ())
182 return &fi;
183
184 return NULL;
185}
186
187static ptid_t
189{
190 struct fork_info *fork = find_fork_id (num);
191 if (fork)
192 return fork->ptid;
193 else
194 return ptid_t (-1);
195}
196
197/* Fork list <-> gdb interface. */
198
199/* Utility function for fork_load/fork_save.
200 Calls lseek in the (current) inferior process. */
201
202static off_t
203call_lseek (int fd, off_t offset, int whence)
204{
205 char exp[80];
206
207 snprintf (&exp[0], sizeof (exp), "(long) lseek (%d, %ld, %d)",
208 fd, (long) offset, whence);
209 return (off_t) parse_and_eval_long (&exp[0]);
210}
211
212/* Load infrun state for the fork PTID. */
213
214static void
216{
217 int i;
218
220
221 if (fp->savedregs)
223
226
229
230 /* Now restore the file positions of open file descriptors. */
231 if (fp->filepos)
232 {
233 for (i = 0; i <= fp->maxfd; i++)
234 if (fp->filepos[i] != (off_t) -1)
235 call_lseek (i, fp->filepos[i], SEEK_SET);
236 /* NOTE: I can get away with using SEEK_SET and SEEK_CUR because
237 this is native-only. If it ever has to be cross, we'll have
238 to rethink this. */
239 }
240}
241
242/* Save infrun state for the fork FP. */
243
244static void
246{
247 char path[PATH_MAX];
248 struct dirent *de;
249 DIR *d;
250
251 if (fp->savedregs)
252 delete fp->savedregs;
253
256
257 /* Now save the 'state' (file position) of all open file descriptors.
258 Unfortunately fork does not take care of that for us... */
259 snprintf (path, PATH_MAX, "/proc/%ld/fd", (long) fp->ptid.pid ());
260 if ((d = opendir (path)) != NULL)
261 {
262 long tmp;
263
264 fp->maxfd = 0;
265 while ((de = readdir (d)) != NULL)
266 {
267 /* Count open file descriptors (actually find highest
268 numbered). */
269 tmp = strtol (&de->d_name[0], NULL, 10);
270 if (fp->maxfd < tmp)
271 fp->maxfd = tmp;
272 }
273 /* Allocate array of file positions. */
274 fp->filepos = XRESIZEVEC (off_t, fp->filepos, fp->maxfd + 1);
275
276 /* Initialize to -1 (invalid). */
277 for (tmp = 0; tmp <= fp->maxfd; tmp++)
278 fp->filepos[tmp] = -1;
279
280 /* Now find actual file positions. */
281 rewinddir (d);
282 while ((de = readdir (d)) != NULL)
283 if (isdigit (de->d_name[0]))
284 {
285 tmp = strtol (&de->d_name[0], NULL, 10);
286 fp->filepos[tmp] = call_lseek (tmp, 0, SEEK_CUR);
287 }
288 closedir (d);
289 }
290}
291
292/* Kill 'em all, let God sort 'em out... */
293
294void
296{
297 /* Walk list and kill every pid. No need to treat the
298 current inferior_ptid as special (we do not return a
299 status for it) -- however any process may be a child
300 or a parent, so may get a SIGCHLD from a previously
301 killed child. Wait them all out. */
302
303 for (fork_info &fi : fork_list)
304 {
305 pid_t pid = fi.ptid.pid ();
306 int status;
307 pid_t ret;
308 do {
309 /* Use SIGKILL instead of PTRACE_KILL because the former works even
310 if the thread is running, while the later doesn't. */
311 kill (pid, SIGKILL);
312 ret = waitpid (pid, &status, 0);
313 /* We might get a SIGCHLD instead of an exit status. This is
314 aggravated by the first kill above - a child has just
315 died. MVS comment cut-and-pasted from linux-nat. */
316 } while (ret == pid && WIFSTOPPED (status));
317 }
318
319 /* Clear list, prepare to start fresh. */
320 fork_list.clear ();
321}
322
323/* The current inferior_ptid has exited, but there are other viable
324 forks to debug. Delete the exiting one and context-switch to the
325 first available. */
326
327void
329{
330 struct fork_info *last;
331 int status;
332
333 /* Wait just one more time to collect the inferior's exit status.
334 Do not check whether this succeeds though, since we may be
335 dealing with a process that we attached to. Such a process will
336 only report its exit status to its original parent. */
337 waitpid (inferior_ptid.pid (), &status, 0);
338
339 /* OK, presumably inferior_ptid is the one who has exited.
340 We need to delete that one from the fork_list, and switch
341 to the next available fork. */
343
344 /* There should still be a fork - if there's only one left,
345 delete_fork won't remove it, because we haven't updated
346 inferior_ptid yet. */
347 gdb_assert (!fork_list.empty ());
348
349 last = find_last_fork ();
351 gdb_printf (_("[Switching to %s]\n"),
353
354 /* If there's only one fork, switch back to non-fork mode. */
355 if (one_fork_p ())
357}
358
359/* The current inferior_ptid is being detached, but there are other
360 viable forks to debug. Detach and delete it and context-switch to
361 the first available. */
362
363void
364linux_fork_detach (int from_tty)
365{
366 /* OK, inferior_ptid is the one we are detaching from. We need to
367 delete it from the fork_list, and switch to the next available
368 fork. */
369
370 if (ptrace (PTRACE_DETACH, inferior_ptid.pid (), 0, 0))
371 error (_("Unable to detach %s"),
373
375
376 /* There should still be a fork - if there's only one left,
377 delete_fork won't remove it, because we haven't updated
378 inferior_ptid yet. */
379 gdb_assert (!fork_list.empty ());
380
382
383 if (from_tty)
384 gdb_printf (_("[Switching to %s]\n"),
386
387 /* If there's only one fork, switch back to non-fork mode. */
388 if (one_fork_p ())
390}
391
392/* Temporarily switch to the infrun state stored on the fork_info
393 identified by a given ptid_t. When this object goes out of scope,
394 restore the currently selected infrun state. */
395
397{
398public:
399 /* Switch to the infrun state held on the fork_info identified by
400 PPTID. If PPTID is the current inferior then no switch is done. */
401 explicit scoped_switch_fork_info (ptid_t pptid)
402 : m_oldfp (nullptr)
403 {
404 if (pptid != inferior_ptid)
405 {
406 struct fork_info *newfp = nullptr;
407
408 /* Switch to pptid. */
410 gdb_assert (m_oldfp != nullptr);
411 newfp = find_fork_ptid (pptid);
412 gdb_assert (newfp != nullptr);
417 }
418 }
419
420 /* Restore the previously selected infrun state. If the constructor
421 didn't need to switch states, then nothing is done here either. */
423 {
424 if (m_oldfp != nullptr)
425 {
426 /* Switch back to inferior_ptid. */
427 try
428 {
432 }
433 catch (const gdb_exception_quit &ex)
434 {
435 /* We can't throw from a destructor, so re-set the quit flag
436 for later QUIT checking. */
437 set_quit_flag ();
438 }
439 catch (const gdb_exception_forced_quit &ex)
440 {
441 /* Like above, but (eventually) cause GDB to terminate by
442 setting sync_quit_force_run. */
444 }
445 catch (const gdb_exception &ex)
446 {
447 warning (_("Couldn't restore checkpoint state in %s: %s"),
448 target_pid_to_str (m_oldfp->ptid).c_str (),
449 ex.what ());
450 }
451 }
452 }
453
455
456private:
457 /* The fork_info for the previously selected infrun state, or nullptr if
458 we were already in the desired state, and nothing needs to be
459 restored. */
461};
462
463static int
464inferior_call_waitpid (ptid_t pptid, int pid)
465{
466 struct objfile *waitpid_objf;
467 struct value *waitpid_fn = NULL;
468 int ret = -1;
469
470 scoped_switch_fork_info switch_fork_info (pptid);
471
472 /* Get the waitpid_fn. */
473 if (lookup_minimal_symbol ("waitpid", NULL, NULL).minsym != NULL)
474 waitpid_fn = find_function_in_inferior ("waitpid", &waitpid_objf);
475 if (!waitpid_fn
476 && lookup_minimal_symbol ("_waitpid", NULL, NULL).minsym != NULL)
477 waitpid_fn = find_function_in_inferior ("_waitpid", &waitpid_objf);
478 if (waitpid_fn != nullptr)
479 {
480 struct gdbarch *gdbarch = get_current_arch ();
481 struct value *argv[3], *retv;
482
483 /* Get the argv. */
484 argv[0] = value_from_longest (builtin_type (gdbarch)->builtin_int, pid);
485 argv[1] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr, 0);
486 argv[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
487
488 retv = call_function_by_hand (waitpid_fn, NULL, argv);
489
490 if (value_as_long (retv) >= 0)
491 ret = 0;
492 }
493
494 return ret;
495}
496
497/* Fork list <-> user interface. */
498
499static void
500delete_checkpoint_command (const char *args, int from_tty)
501{
502 ptid_t ptid, pptid;
503 struct fork_info *fi;
504
505 if (!args || !*args)
506 error (_("Requires argument (checkpoint id to delete)"));
507
509 if (ptid == minus_one_ptid)
510 error (_("No such checkpoint id, %s"), args);
511
512 if (ptid == inferior_ptid)
513 error (_("\
514Please switch to another checkpoint before deleting the current one"));
515
516 if (ptrace (PTRACE_KILL, ptid.pid (), 0, 0))
517 error (_("Unable to kill pid %s"), target_pid_to_str (ptid).c_str ());
518
519 fi = find_fork_ptid (ptid);
520 gdb_assert (fi);
521 pptid = fi->parent_ptid;
522
523 if (from_tty)
524 gdb_printf (_("Killed %s\n"), target_pid_to_str (ptid).c_str ());
525
527
528 /* If fi->parent_ptid is not a part of lwp but it's a part of checkpoint
529 list, waitpid the ptid.
530 If fi->parent_ptid is a part of lwp and it is stopped, waitpid the
531 ptid. */
532 thread_info *parent = linux_target->find_thread (pptid);
533 if ((parent == NULL && find_fork_ptid (pptid))
534 || (parent != NULL && parent->state == THREAD_STOPPED))
535 {
536 if (inferior_call_waitpid (pptid, ptid.pid ()))
537 warning (_("Unable to wait pid %s"),
538 target_pid_to_str (ptid).c_str ());
539 }
540}
541
542static void
543detach_checkpoint_command (const char *args, int from_tty)
544{
545 ptid_t ptid;
546
547 if (!args || !*args)
548 error (_("Requires argument (checkpoint id to detach)"));
549
551 if (ptid == minus_one_ptid)
552 error (_("No such checkpoint id, %s"), args);
553
554 if (ptid == inferior_ptid)
555 error (_("\
556Please switch to another checkpoint before detaching the current one"));
557
558 if (ptrace (PTRACE_DETACH, ptid.pid (), 0, 0))
559 error (_("Unable to detach %s"), target_pid_to_str (ptid).c_str ());
560
561 if (from_tty)
562 gdb_printf (_("Detached %s\n"), target_pid_to_str (ptid).c_str ());
563
565}
566
567/* Print information about currently known checkpoints. */
568
569static void
570info_checkpoints_command (const char *arg, int from_tty)
571{
572 struct gdbarch *gdbarch = get_current_arch ();
573 int requested = -1;
574 const fork_info *printed = NULL;
575
576 if (arg && *arg)
577 requested = (int) parse_and_eval_long (arg);
578
579 for (const fork_info &fi : fork_list)
580 {
581 if (requested > 0 && fi.num != requested)
582 continue;
583
584 printed = &fi;
585 if (fi.ptid == inferior_ptid)
586 gdb_printf ("* ");
587 else
588 gdb_printf (" ");
589
590 ULONGEST pc = fi.pc;
591 gdb_printf ("%d %s", fi.num, target_pid_to_str (fi.ptid).c_str ());
592 if (fi.num == 0)
593 gdb_printf (_(" (main process)"));
594 gdb_printf (_(" at "));
595 gdb_puts (paddress (gdbarch, pc));
596
597 symtab_and_line sal = find_pc_line (pc, 0);
598 if (sal.symtab)
599 gdb_printf (_(", file %s"),
601 if (sal.line)
602 gdb_printf (_(", line %d"), sal.line);
603 if (!sal.symtab && !sal.line)
604 {
605 struct bound_minimal_symbol msym;
606
607 msym = lookup_minimal_symbol_by_pc (pc);
608 if (msym.minsym)
609 gdb_printf (", <%s>", msym.minsym->linkage_name ());
610 }
611
612 gdb_putc ('\n');
613 }
614 if (printed == NULL)
615 {
616 if (requested > 0)
617 gdb_printf (_("No checkpoint number %d.\n"), requested);
618 else
619 gdb_printf (_("No checkpoints.\n"));
620 }
621}
622
623/* The PID of the process we're checkpointing. */
624static int checkpointing_pid = 0;
625
626int
628{
629 return (checkpointing_pid == pid);
630}
631
632/* Return true if the current inferior is multi-threaded. */
633
634static bool
636{
637 int count = 0;
638
639 /* Return true as soon as we see the second thread of the current
640 inferior. */
641 for (thread_info *tp ATTRIBUTE_UNUSED : current_inferior ()->threads ())
642 if (++count > 1)
643 return true;
644
645 return false;
646}
647
648static void
649checkpoint_command (const char *args, int from_tty)
650{
651 struct objfile *fork_objf;
652 struct gdbarch *gdbarch;
653 struct target_waitstatus last_target_waitstatus;
654 ptid_t last_target_ptid;
655 struct value *fork_fn = NULL, *ret;
656 struct fork_info *fp;
657 pid_t retpid;
658
659 if (!target_has_execution ())
660 error (_("The program is not being run."));
661
662 /* Ensure that the inferior is not multithreaded. */
665 error (_("checkpoint: can't checkpoint multiple threads."));
666
667 /* Make the inferior fork, record its (and gdb's) state. */
668
669 if (lookup_minimal_symbol ("fork", NULL, NULL).minsym != NULL)
670 fork_fn = find_function_in_inferior ("fork", &fork_objf);
671 if (!fork_fn)
672 if (lookup_minimal_symbol ("_fork", NULL, NULL).minsym != NULL)
673 fork_fn = find_function_in_inferior ("fork", &fork_objf);
674 if (!fork_fn)
675 error (_("checkpoint: can't find fork function in inferior."));
676
677 gdbarch = fork_objf->arch ();
678 ret = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
679
680 /* Tell linux-nat.c that we're checkpointing this inferior. */
681 {
682 scoped_restore save_pid
683 = make_scoped_restore (&checkpointing_pid, inferior_ptid.pid ());
684
685 ret = call_function_by_hand (fork_fn, NULL, {});
686 }
687
688 if (!ret) /* Probably can't happen. */
689 error (_("checkpoint: call_function_by_hand returned null."));
690
691 retpid = value_as_long (ret);
692 get_last_target_status (nullptr, &last_target_ptid, &last_target_waitstatus);
693
694 fp = find_fork_pid (retpid);
695
696 if (from_tty)
697 {
698 int parent_pid;
699
700 gdb_printf (_("checkpoint %d: fork returned pid %ld.\n"),
701 fp != NULL ? fp->num : -1, (long) retpid);
702 if (info_verbose)
703 {
704 parent_pid = last_target_ptid.lwp ();
705 if (parent_pid == 0)
706 parent_pid = last_target_ptid.pid ();
707 gdb_printf (_(" gdb says parent = %ld.\n"),
708 (long) parent_pid);
709 }
710 }
711
712 if (!fp)
713 error (_("Failed to find new fork"));
714
715 if (one_fork_p ())
716 {
717 /* Special case -- if this is the first fork in the list (the
718 list was hitherto empty), then add inferior_ptid first, as a
719 special zeroeth fork id. */
720 fork_list.emplace_front (inferior_ptid.pid ());
721 }
722
724 fp->parent_ptid = last_target_ptid;
725}
726
727static void
728linux_fork_context (struct fork_info *newfp, int from_tty)
729{
730 /* Now we attempt to switch processes. */
731 struct fork_info *oldfp;
732
733 gdb_assert (newfp != NULL);
734
736 gdb_assert (oldfp != NULL);
737
742
743 gdb_printf (_("Switching to %s\n"),
745
747}
748
749/* Switch inferior process (checkpoint) context, by checkpoint id. */
750static void
751restart_command (const char *args, int from_tty)
752{
753 struct fork_info *fp;
754
755 if (!args || !*args)
756 error (_("Requires argument (checkpoint id to restart)"));
757
758 if ((fp = find_fork_id (parse_and_eval_long (args))) == NULL)
759 error (_("Not found: checkpoint id %s"), args);
760
761 linux_fork_context (fp, from_tty);
762}
763
765void
767{
768 /* Checkpoint command: create a fork of the inferior process
769 and set it aside for later debugging. */
770
771 add_com ("checkpoint", class_obscure, checkpoint_command, _("\
772Fork a duplicate process (experimental)."));
773
774 /* Restart command: restore the context of a specified checkpoint
775 process. */
776
777 add_com ("restart", class_obscure, restart_command, _("\
778Restore program context from a checkpoint.\n\
779Usage: restart N\n\
780Argument N is checkpoint ID, as displayed by 'info checkpoints'."));
781
782 /* Delete checkpoint command: kill the process and remove it from
783 the fork list. */
784
786Delete a checkpoint (experimental)."),
787 &deletelist);
788
789 /* Detach checkpoint command: release the process to run independently,
790 and remove it from the fork list. */
791
793Detach from a checkpoint (experimental)."),
794 &detachlist);
795
796 /* Info checkpoints command: list all forks/checkpoints
797 currently under gdb's control. */
798
799 add_info ("checkpoints", info_checkpoints_command,
800 _("IDs of currently known checkpoints."));
801}
void xfree(void *)
struct gdbarch * get_current_arch(void)
Definition arch-utils.c:846
int remove_breakpoints(void)
void insert_breakpoints(void)
inf_threads_range threads()
Definition inferior.h:472
virtual void low_forget_process(pid_t pid)
Definition linux-nat.h:167
thread_info * find_thread(ptid_t ptid)
void restore(readonly_detached_regcache *src)
Definition regcache.c:277
scoped_switch_fork_info(ptid_t pptid)
Definition linux-fork.c:401
DISABLE_COPY_AND_ASSIGN(scoped_switch_fork_info)
struct fork_info * m_oldfp
Definition linux-fork.c:460
enum thread_state state
Definition gdbthread.h:339
void set_stop_pc(CORE_ADDR stop_pc)
Definition gdbthread.h:372
struct cmd_list_element * deletelist
Definition cli-cmds.c:107
struct cmd_list_element * detachlist
Definition cli-cmds.c:111
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
@ class_obscure
Definition command.h:64
#define SEEK_SET
Definition defs.h:101
void set_force_quit_flag()
Definition event-top.c:1149
void set_quit_flag(void)
Definition extension.c:833
bool info_verbose
Definition top.c:1941
#define SEEK_CUR
Definition defs.h:104
LONGEST parse_and_eval_long(const char *exp)
Definition eval.c:62
void reinit_frame_cache(void)
Definition frame.c:2107
frame_info_ptr get_selected_frame(const char *message)
Definition frame.c:1888
@ SRC_AND_LOC
Definition frame.h:811
void print_stack_frame(frame_info_ptr, int print_level, enum print_what print_what, int set_current_sal)
Definition stack.c:353
#define ptrace(request, pid, addr, data)
Definition gdb_ptrace.h:141
@ THREAD_STOPPED
Definition gdbthread.h:72
void update_thread_list(void)
Definition thread.c:2086
struct thread_info * inferior_thread(void)
Definition thread.c:85
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition gnu-nat.c:1791
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1790
struct value * call_function_by_hand(struct value *function, type *default_return_type, gdb::array_view< value * > args)
Definition infcall.c:824
ptid_t inferior_ptid
Definition infcmd.c:74
struct inferior * current_inferior(void)
Definition inferior.c:55
void nullify_last_target_wait_ptid(void)
Definition infrun.c:4635
void get_last_target_status(process_stratum_target **target, ptid_t *ptid, target_waitstatus *status)
Definition infrun.c:4621
static off_t call_lseek(int fd, off_t offset, int whence)
Definition linux-fork.c:203
int linux_fork_checkpointing_p(int pid)
Definition linux-fork.c:627
static bool inf_has_multiple_threads()
Definition linux-fork.c:635
void linux_fork_killall(void)
Definition linux-fork.c:295
static int highest_fork_num
Definition linux-fork.c:87
static void info_checkpoints_command(const char *arg, int from_tty)
Definition linux-fork.c:570
static struct fork_info * find_fork_id(int num)
Definition linux-fork.c:167
static void delete_checkpoint_command(const char *args, int from_tty)
Definition linux-fork.c:500
static ptid_t fork_id_to_ptid(int num)
Definition linux-fork.c:188
void add_fork(pid_t pid)
Definition linux-fork.c:119
static std::list< fork_info > fork_list
Definition linux-fork.c:86
static void fork_load_infrun_state(struct fork_info *fp)
Definition linux-fork.c:215
static void delete_fork(ptid_t ptid)
Definition linux-fork.c:131
static int checkpointing_pid
Definition linux-fork.c:624
static int inferior_call_waitpid(ptid_t pptid, int pid)
Definition linux-fork.c:464
static void checkpoint_command(const char *args, int from_tty)
Definition linux-fork.c:649
void _initialize_linux_fork()
Definition linux-fork.c:766
static void restart_command(const char *args, int from_tty)
Definition linux-fork.c:751
static bool one_fork_p()
Definition linux-fork.c:111
static void detach_checkpoint_command(const char *args, int from_tty)
Definition linux-fork.c:543
void linux_fork_mourn_inferior(void)
Definition linux-fork.c:328
int forks_exist_p(void)
Definition linux-fork.c:92
static struct fork_info * find_last_fork(void)
Definition linux-fork.c:100
struct fork_info * find_fork_pid(pid_t pid)
Definition linux-fork.c:178
static void linux_fork_context(struct fork_info *newfp, int from_tty)
Definition linux-fork.c:728
void linux_fork_detach(int from_tty)
Definition linux-fork.c:364
static struct fork_info * find_fork_ptid(ptid_t ptid)
Definition linux-fork.c:156
static void fork_save_infrun_state(struct fork_info *fp)
Definition linux-fork.c:245
struct linux_nat_target * linux_target
Definition linux-nat.c:189
void linux_nat_switch_fork(ptid_t new_ptid)
Definition linux-nat.c:881
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
Definition minsyms.c:996
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition regcache.c:1333
struct regcache * get_current_regcache(void)
Definition regcache.c:429
void registers_changed(void)
Definition regcache.c:580
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition source.c:1269
struct minimal_symbol * minsym
Definition minsyms.h:49
CORE_ADDR pc
Definition linux-fork.c:78
readonly_detached_regcache * savedregs
Definition linux-fork.c:76
off_t * filepos
Definition linux-fork.c:81
ptid_t parent_ptid
Definition linux-fork.c:69
ptid_t ptid
Definition linux-fork.c:68
fork_info(pid_t pid)
Definition linux-fork.c:43
const char * linkage_name() const
Definition symtab.h:460
struct gdbarch * arch() const
Definition objfiles.h:507
struct symtab * symtab
Definition symtab.h:2328
Definition value.h:130
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition symtab.c:3295
bool target_has_execution(inferior *inf)
Definition target.c:201
std::string target_pid_to_str(ptid_t ptid)
Definition target.c:2623
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void gdb_putc(int c)
Definition utils.c:1862
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1809
struct value * find_function_in_inferior(const char *name, struct objfile **objf_p)
Definition valops.c:117
struct value * value_from_longest(struct type *type, LONGEST num)
Definition value.c:3438
LONGEST value_as_long(struct value *val)
Definition value.c:2554
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
Definition value.c:3500
#define nullptr
Definition x86-cpuid.h:28