GDB (xrefs)

fork-inferior.c
Go to the documentation of this file.
1 /* Fork a Unix child process, and set up to debug it, for GDB and GDBserver.
2
3 Copyright (C) 1990-2018 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 "common-defs.h"
21 #include "fork-inferior.h"
22 #include "target/waitstatus.h"
23 #include "filestuff.h"
24 #include "target/target.h"
25 #include "common-inferior.h"
26 #include "common-gdbthread.h"
27 #include "signals-state-save-restore.h"
28 #include "gdb_tilde_expand.h"
29 #include <vector>
30
31 extern char **environ;
32
33 /* Default shell file to be used if 'startup-with-shell' is set but
34 $SHELL is not. */
35 #define SHELL_FILE "/bin/sh"
36
37 /* Build the argument vector for execv(3). */
38
39 class execv_argv
40 {
41 public:
42 /* EXEC_FILE is the file to run. ALLARGS is a string containing the
43 arguments to the program. If starting with a shell, SHELL_FILE
44 is the shell to run. Otherwise, SHELL_FILE is NULL. */
45 execv_argv (const char *exec_file, const std::string &allargs,
46 const char *shell_file);
47
48 /* Return a pointer to the built argv, in the type expected by
49 execv. The result is (only) valid for as long as this execv_argv
50 object is live. We return a "char **" because that's the type
51 that the execv functions expect. Note that it is guaranteed that
52 the execv functions do not modify the argv[] array nor the
53 strings to which the array point. */
54 char **argv ()
55 {
56 return const_cast<char **> (&m_argv[0]);
57 }
58
59 private:
60 DISABLE_COPY_AND_ASSIGN (execv_argv);
61
62 /* Helper methods for constructing the argument vector. */
63
64 /* Used when building an argv for a straight execv call, without
65 going via the shell. */
66 void init_for_no_shell (const char *exec_file,
67 const std::string &allargs);
68
69 /* Used when building an argv for execing a shell that execs the
70 child program. */
71 void init_for_shell (const char *exec_file,
72 const std::string &allargs,
73 const char *shell_file);
74
75 /* The argument vector built. Holds non-owning pointers. Elements
76 either point to the strings passed to the execv_argv ctor, or
77 inside M_STORAGE. */
78 std::vector<const char *> m_argv;
79
80 /* Storage. In the no-shell case, this contains a copy of the
81 arguments passed to the ctor, split by '\0'. In the shell case,
82 this contains the quoted shell command. I.e., SHELL_COMMAND in
83 {"$SHELL" "-c", SHELL_COMMAND, NULL}. */
84 std::string m_storage;
85 };
86
87 /* Create argument vector for straight call to execvp. Breaks up
88 ALLARGS into an argument vector suitable for passing to execvp and
89 stores it in M_ARGV. E.g., on "run a b c d" this routine would get
90 as input the string "a b c d", and as output it would fill in
91 M_ARGV with the four arguments "a", "b", "c", "d". Each argument
92 in M_ARGV points to a substring of a copy of ALLARGS stored in
93 M_STORAGE. */
94
95 void
96 execv_argv::init_for_no_shell (const char *exec_file,
97 const std::string &allargs)
98 {
99
100 /* Save/work with a copy stored in our storage. The pointers pushed
101 to M_ARGV point directly into M_STORAGE, which is modified in
102 place with the necessary NULL terminators. This avoids N heap
103 allocations and string dups when 1 is sufficient. */
104 std::string &args_copy = m_storage = allargs;
105
106 m_argv.push_back (exec_file);
107
108 for (size_t cur_pos = 0; cur_pos < args_copy.size ();)
109 {
110 /* Skip whitespace-like chars. */
111 std::size_t pos = args_copy.find_first_not_of (" \t\n", cur_pos);
112
113 if (pos != std::string::npos)
114 cur_pos = pos;
115
116 /* Find the position of the next separator. */
117 std::size_t next_sep = args_copy.find_first_of (" \t\n", cur_pos);
118
119 if (next_sep == std::string::npos)
120 {
121 /* No separator found, which means this is the last
122 argument. */
123 next_sep = args_copy.size ();
124 }
125 else
126 {
127 /* Replace the separator with a terminator. */
128 args_copy[next_sep++] = '\0';
129 }
130
131 m_argv.push_back (&args_copy[cur_pos]);
132
133 cur_pos = next_sep;
134 }
135
136 /* NULL-terminate the vector. */
137 m_argv.push_back (NULL);
138 }
139
140 /* When executing a command under the given shell, return true if the
141 '!' character should be escaped when embedded in a quoted
142 command-line argument. */
143
144 static bool
145 escape_bang_in_quoted_argument (const char *shell_file)
146 {
147 size_t shell_file_len = strlen (shell_file);
148
149 /* Bang should be escaped only in C Shells. For now, simply check
150 that the shell name ends with 'csh', which covers at least csh
151 and tcsh. This should be good enough for now. */
152
153 if (shell_file_len < 3)
154 return false;
155
156 if (shell_file[shell_file_len - 3] == 'c'
157 && shell_file[shell_file_len - 2] == 's'
158 && shell_file[shell_file_len - 1] == 'h')
159 return true;
160
161 return false;
162 }
163
164 /* See declaration. */
165
166 execv_argv::execv_argv (const char *exec_file,
167 const std::string &allargs,
168 const char *shell_file)
169 {
170 if (shell_file == NULL)
171 init_for_no_shell (exec_file, allargs);
172 else
173 init_for_shell (exec_file, allargs, shell_file);
174 }
175
176 /* See declaration. */
177
178 void
179 execv_argv::init_for_shell (const char *exec_file,
180 const std::string &allargs,
181 const char *shell_file)
182 {
183 const char *exec_wrapper = get_exec_wrapper ();
184
185 /* We're going to call a shell. */
186 bool escape_bang = escape_bang_in_quoted_argument (shell_file);
187
188 /* We need to build a new shell command string, and make argv point
189 to it. So build it in the storage. */
190 std::string &shell_command = m_storage;
191
192 shell_command = "exec ";
193
194 /* Add any exec wrapper. That may be a program name with arguments,
195 so the user must handle quoting. */
196 if (exec_wrapper != NULL)
197 {
198 shell_command += exec_wrapper;
199 shell_command += ' ';
200 }
201
202 /* Now add exec_file, quoting as necessary. */
203
204 /* Quoting in this style is said to work with all shells. But csh
205 on IRIX 4.0.1 can't deal with it. So we only quote it if we need
206 to. */
207 bool need_to_quote;
208 const char *p = exec_file;
209 while (1)
210 {
211 switch (*p)
212 {
213 case '\'':
214 case '!':
215 case '"':
216 case '(':
217 case ')':
218 case '$':
219 case '&':
220 case ';':
221 case '<':
222 case '>':
223 case ' ':
224 case '\n':
225 case '\t':
226 need_to_quote = true;
227 goto end_scan;
228
229 case '\0':
230 need_to_quote = false;
231 goto end_scan;
232
233 default:
234 break;
235 }
236 ++p;
237 }
238 end_scan:
239 if (need_to_quote)
240 {
241 shell_command += '\'';
242 for (p = exec_file; *p != '\0'; ++p)
243 {
244 if (*p == '\'')
245 shell_command += "'\\''";
246 else if (*p == '!' && escape_bang)
247 shell_command += "\\!";
248 else
249 shell_command += *p;
250 }
251 shell_command += '\'';
252 }
253 else
254 shell_command += exec_file;
255
256 shell_command += ' ' + allargs;
257
258 /* If we decided above to start up with a shell, we exec the shell.
259 "-c" says to interpret the next arg as a shell command to
260 execute, and this command is "exec <target-program> <args>". */
261 m_argv.reserve (4);
262 m_argv.push_back (shell_file);
263 m_argv.push_back ("-c");
264 m_argv.push_back (shell_command.c_str ());
265 m_argv.push_back (NULL);
266 }
267
268 /* Return the shell that must be used to startup the inferior. The
269 first attempt is the environment variable SHELL; if it is not set,
270 then we default to SHELL_FILE. */
271
272 static const char *
273 get_startup_shell ()
274 {
275 static const char *ret;
276
277 ret = getenv ("SHELL");
278 if (ret == NULL)
279 ret = SHELL_FILE;
280
281 return ret;
282 }
283
284 /* See nat/fork-inferior.h. */
285
286 pid_t
287 fork_inferior (const char *exec_file_arg, const std::string &allargs,
288 char **env, void (*traceme_fun) (),
289 void (*init_trace_fun) (int), void (*pre_trace_fun) (),
290 const char *shell_file_arg,
291 void (*exec_fun)(const char *file, char * const *argv,
292 char * const *env))
293 {
294 pid_t pid;
295 /* Set debug_fork then attach to the child while it sleeps, to debug. */
296 int debug_fork = 0;
297 const char *shell_file;
298 const char *exec_file;
299 char **save_our_env;
300 int i;
301 int save_errno;
302 const char *inferior_cwd;
303 std::string expanded_inferior_cwd;
304
305 /* If no exec file handed to us, get it from the exec-file command
306 -- with a good, common error message if none is specified. */
307 if (exec_file_arg == NULL)
308 exec_file = get_exec_file (1);
309 else
310 exec_file = exec_file_arg;
311
312 /* 'startup_with_shell' is declared in inferior.h and bound to the
313 "set startup-with-shell" option. If 0, we'll just do a
314 fork/exec, no shell, so don't bother figuring out what shell. */
315 if (startup_with_shell)
316 {
317 shell_file = shell_file_arg;
318
319 /* Figure out what shell to start up the user program under. */
320 if (shell_file == NULL)
321 shell_file = get_startup_shell ();
322
323 gdb_assert (shell_file != NULL);
324 }
325 else
326 shell_file = NULL;
327
328 /* Build the argument vector. */
329 execv_argv child_argv (exec_file, allargs, shell_file);
330
331 /* Retain a copy of our environment variables, since the child will
332 replace the value of environ and if we're vforked, we have to
333 restore it. */
334 save_our_env = environ;
335
336 /* Perform any necessary actions regarding to TTY before the
337 fork/vfork call. */
338 prefork_hook (allargs.c_str ());
339
340 /* It is generally good practice to flush any possible pending stdio
341 output prior to doing a fork, to avoid the possibility of both
342 the parent and child flushing the same data after the fork. */
343 gdb_flush_out_err ();
344
345 /* Check if the user wants to set a different working directory for
346 the inferior. */
347 inferior_cwd = get_inferior_cwd ();
348
349 if (inferior_cwd != NULL)
350 {
351 /* Expand before forking because between fork and exec, the child
352 process may only execute async-signal-safe operations. */
353 expanded_inferior_cwd = gdb_tilde_expand (inferior_cwd);
354 inferior_cwd = expanded_inferior_cwd.c_str ();
355 }
356
357 /* If there's any initialization of the target layers that must
358 happen to prepare to handle the child we're about fork, do it
359 now... */
360 if (pre_trace_fun != NULL)
361 (*pre_trace_fun) ();
362
363 /* Create the child process. Since the child process is going to
364 exec(3) shortly afterwards, try to reduce the overhead by
365 calling vfork(2). However, if PRE_TRACE_FUN is non-null, it's
366 likely that this optimization won't work since there's too much
367 work to do between the vfork(2) and the exec(3). This is known
368 to be the case on ttrace(2)-based HP-UX, where some handshaking
369 between parent and child needs to happen between fork(2) and
370 exec(2). However, since the parent is suspended in the vforked
371 state, this doesn't work. Also note that the vfork(2) call might
372 actually be a call to fork(2) due to the fact that autoconf will
373 ``#define vfork fork'' on certain platforms. */
374 #if !(defined(__UCLIBC__) && defined(HAS_NOMMU))
375 if (pre_trace_fun || debug_fork)
376 pid = fork ();
377 else
378 #endif
379 pid = vfork ();
380
381 if (pid < 0)
382 perror_with_name (("vfork"));
383
384 if (pid == 0)
385 {
386 /* Close all file descriptors except those that gdb inherited
387 (usually 0/1/2), so they don't leak to the inferior. Note
388 that this closes the file descriptors of all secondary
389 UIs. */
390 close_most_fds ();
391
392 /* Change to the requested working directory if the user
393 requested it. */
394 if (inferior_cwd != NULL)
395 {
396 if (chdir (inferior_cwd) < 0)
397 trace_start_error_with_name (inferior_cwd);
398 }
399
400 if (debug_fork)
401 sleep (debug_fork);
402
403 /* Execute any necessary post-fork actions before we exec. */
404 postfork_child_hook ();
405
406 /* Changing the signal handlers for the inferior after
407 a vfork can also change them for the superior, so we don't mess
408 with signals here. See comments in
409 initialize_signals for how we get the right signal handlers
410 for the inferior. */
411
412 /* "Trace me, Dr. Memory!" */
413 (*traceme_fun) ();
414
415 /* The call above set this process (the "child") as debuggable
416 by the original gdb process (the "parent"). Since processes
417 (unlike people) can have only one parent, if you are debugging
418 gdb itself (and your debugger is thus _already_ the
419 controller/parent for this child), code from here on out is
420 undebuggable. Indeed, you probably got an error message
421 saying "not parent". Sorry; you'll have to use print
422 statements! */
423
424 restore_original_signals_state ();
425
426 /* There is no execlpe call, so we have to set the environment
427 for our child in the global variable. If we've vforked, this
428 clobbers the parent, but environ is restored a few lines down
429 in the parent. By the way, yes we do need to look down the
430 path to find $SHELL. Rich Pixley says so, and I agree. */
431 environ = env;
432
433 char **argv = child_argv.argv ();
434
435 if (exec_fun != NULL)
436 (*exec_fun) (argv[0], &argv[0], env);
437 else
438 execvp (argv[0], &argv[0]);
439
440 /* If we get here, it's an error. */
441 save_errno = errno;
442 warning ("Cannot exec %s", argv[0]);
443
444 for (i = 1; argv[i] != NULL; i++)
445 warning (" %s", argv[i]);
446
447 warning ("Error: %s\n", safe_strerror (save_errno));
448
449 _exit (0177);
450 }
451
452 /* Restore our environment in case a vforked child clob'd it. */
453 environ = save_our_env;
454
455 postfork_hook (pid);
456
457 /* Now that we have a child process, make it our target, and
458 initialize anything target-vector-specific that needs
459 initializing. */
460 if (init_trace_fun)
461 (*init_trace_fun) (pid);
462
463 /* We are now in the child process of interest, having exec'd the
464 correct program, and are poised at the first instruction of the
465 new program. */
466 return pid;
467 }
468
469 /* See nat/fork-inferior.h. */
470
471 ptid_t
472 startup_inferior (pid_t pid, int ntraps,
473 struct target_waitstatus *last_waitstatus,
474 ptid_t *last_ptid)
475 {
476 int pending_execs = ntraps;
477 int terminal_initted = 0;
478 ptid_t resume_ptid;
479
480 if (startup_with_shell)
481 {
482 /* One trap extra for exec'ing the shell. */
483 pending_execs++;
484 }
485
486 if (target_supports_multi_process ())
487 resume_ptid = pid_to_ptid (pid);
488 else
489 resume_ptid = minus_one_ptid;
490
491 /* The process was started by the fork that created it, but it will
492 have stopped one instruction after execing the shell. Here we
493 must get it up to actual execution of the real program. */
494 if (get_exec_wrapper () != NULL)
495 pending_execs++;
496
497 while (1)
498 {
499 enum gdb_signal resume_signal = GDB_SIGNAL_0;
500 ptid_t event_ptid;
501
502 struct target_waitstatus ws;
503 memset (&ws, 0, sizeof (ws));
504 event_ptid = target_wait (resume_ptid, &ws, 0);
505
506 if (last_waitstatus != NULL)
507 *last_waitstatus = ws;
508 if (last_ptid != NULL)
509 *last_ptid = event_ptid;
510
511 if (ws.kind == TARGET_WAITKIND_IGNORE)
512 /* The inferior didn't really stop, keep waiting. */
513 continue;
514
515 switch (ws.kind)
516 {
517 case TARGET_WAITKIND_SPURIOUS:
518 case TARGET_WAITKIND_LOADED:
519 case TARGET_WAITKIND_FORKED:
520 case TARGET_WAITKIND_VFORKED:
521 case TARGET_WAITKIND_SYSCALL_ENTRY:
522 case TARGET_WAITKIND_SYSCALL_RETURN:
523 /* Ignore gracefully during startup of the inferior. */
524 switch_to_thread (event_ptid);
525 break;
526
527 case TARGET_WAITKIND_SIGNALLED:
528 target_terminal::ours ();
529 target_mourn_inferior (event_ptid);
530 error (_("During startup program terminated with signal %s, %s."),
531 gdb_signal_to_name (ws.value.sig),
532 gdb_signal_to_string (ws.value.sig));
533 return resume_ptid;
534
535 case TARGET_WAITKIND_EXITED:
536 target_terminal::ours ();
537 target_mourn_inferior (event_ptid);
538 if (ws.value.integer)
539 error (_("During startup program exited with code %d."),
540 ws.value.integer);
541 else
542 error (_("During startup program exited normally."));
543 return resume_ptid;
544
545 case TARGET_WAITKIND_EXECD:
546 /* Handle EXEC signals as if they were SIGTRAP signals. */
547 xfree (ws.value.execd_pathname);
548 resume_signal = GDB_SIGNAL_TRAP;
549 switch_to_thread (event_ptid);
550 break;
551
552 case TARGET_WAITKIND_STOPPED:
553 resume_signal = ws.value.sig;
554 switch_to_thread (event_ptid);
555 break;
556 }
557
558 if (resume_signal != GDB_SIGNAL_TRAP)
559 {
560 /* Let shell child handle its own signals in its own way. */
561 target_continue (resume_ptid, resume_signal);
562 }
563 else
564 {
565 /* We handle SIGTRAP, however; it means child did an exec. */
566 if (!terminal_initted)
567 {
568 /* Now that the child has exec'd we know it has already
569 set its process group. On POSIX systems, tcsetpgrp
570 will fail with EPERM if we try it before the child's
571 setpgid. */
572
573 /* Set up the "saved terminal modes" of the inferior
574 based on what modes we are starting it with. */
575 target_terminal::init ();
576
577 /* Install inferior's terminal modes. */
578 target_terminal::inferior ();
579
580 terminal_initted = 1;
581 }
582
583 if (--pending_execs == 0)
584 break;
585
586 /* Just make it go on. */
587 target_continue_no_signal (resume_ptid);
588 }
589 }
590
591 return resume_ptid;
592 }
593
594 /* See nat/fork-inferior.h. */
595
596 void
597 trace_start_error (const char *fmt, ...)
598 {
599 va_list ap;
600
601 va_start (ap, fmt);
602 warning ("Could not trace the inferior process.\nError: ");
603 vwarning (fmt, ap);
604 va_end (ap);
605
606 gdb_flush_out_err ();
607 _exit (0177);
608 }
609
610 /* See nat/fork-inferior.h. */
611
612 void
613 trace_start_error_with_name (const char *string)
614 {
615 trace_start_error ("%s: %s", string, safe_strerror (errno));
616 }
string
const char * string
Definition: signals.c:50
TARGET_WAITKIND_SYSCALL_RETURN
Definition: waitstatus.h:72
startup_inferior
ptid_t startup_inferior(pid_t pid, int ntraps, struct target_waitstatus *last_waitstatus, ptid_t *last_ptid)
Definition: fork-inferior.c:472
signals-state-save-restore.h
target_waitstatus
Definition: waitstatus.h:104
exec_wrapper
static char * exec_wrapper
Definition: fork-child.c:36
target_wait
ptid_t target_wait(ptid_t ptid, struct target_waitstatus *status, int options)
Definition: target.c:2177
TARGET_WAITKIND_SYSCALL_ENTRY
Definition: waitstatus.h:71
SHELL_FILE
#define SHELL_FILE
Definition: fork-inferior.c:35
xfree
void xfree(void *)
pid
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:1824
common-gdbthread.h
target_supports_multi_process
int target_supports_multi_process(void)
Definition: target.c:2643
escape_bang_in_quoted_argument
static bool escape_bang_in_quoted_argument(const char *shell_file)
Definition: fork-inferior.c:145
gdb_flush_out_err
void gdb_flush_out_err()
Definition: fork-child.c:49
warning
void warning(const char *fmt,...)
Definition: errors.c:26
execv_argv::m_storage
std::string m_storage
Definition: fork-inferior.c:84
get_exec_file
char * get_exec_file(int err)
Definition: corefile.c:167
memset
void * memset(T *s, int c, size_t n)=delete
target_waitstatus::value
union target_waitstatus::@174 value
prefork_hook
void prefork_hook(const char *args)
Definition: fork-child.c:62
execv_argv::init_for_shell
void init_for_shell(const char *exec_file, const std::string &allargs, const char *shell_file)
Definition: fork-inferior.c:179
TARGET_WAITKIND_EXECD
Definition: waitstatus.h:56
_
#define _(String)
Definition: gdb_locale.h:35
TARGET_WAITKIND_FORKED
Definition: waitstatus.h:48
target_terminal::ours
static void ours()
Definition: target.c:483
target_terminal::inferior
static void inferior()
Definition: target.c:450
target_terminal::init
static void init()
Definition: target.c:440
target.h
TARGET_WAITKIND_SIGNALLED
Definition: waitstatus.h:39
switch_to_thread
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1445
execv_argv::execv_argv
execv_argv(const char *exec_file, const std::string &allargs, const char *shell_file)
Definition: fork-inferior.c:166
resume_signal
static int resume_signal
Definition: go32-nat.c:347
target_waitstatus::sig
enum gdb_signal sig
Definition: waitstatus.h:114
ptid_t
Definition: ptid.h:35
get_startup_shell
static const char * get_startup_shell()
Definition: fork-inferior.c:273
pid_to_ptid
ptid_t pid_to_ptid(int pid)
Definition: ptid.c:39
execv_argv::DISABLE_COPY_AND_ASSIGN
DISABLE_COPY_AND_ASSIGN(execv_argv)
get_exec_wrapper
const char * get_exec_wrapper()
Definition: fork-child.c:41
common-defs.h
trace_start_error
void trace_start_error(const char *fmt,...)
Definition: fork-inferior.c:597
target_mourn_inferior
void target_mourn_inferior(ptid_t ptid)
Definition: target.c:2298
restore_original_signals_state
void restore_original_signals_state(void)
Definition: signals-state-save-restore.c:96
gdb_signal_to_name
const char * gdb_signal_to_name(enum gdb_signal)
Definition: signals.c:78
close_most_fds
void close_most_fds(void)
Definition: filestuff.c:216
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
get_inferior_cwd
const char * get_inferior_cwd()
Definition: infcmd.c:237
waitstatus.h
execv_argv
Definition: fork-inferior.c:39
environ
char ** environ
target_continue
void target_continue(ptid_t ptid, enum gdb_signal signal)
Definition: target.c:3383
target_waitstatus::execd_pathname
char * execd_pathname
Definition: waitstatus.h:118
target_waitstatus::integer
int integer
Definition: waitstatus.h:112
fork-inferior.h
trace_start_error_with_name
void trace_start_error_with_name(const char *string)
Definition: fork-inferior.c:613
perror_with_name
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:692
postfork_hook
void postfork_hook(pid_t pid)
Definition: fork-child.c:79
execv_argv::argv
char ** argv()
Definition: fork-inferior.c:54
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
target_waitstatus::kind
enum target_waitkind kind
Definition: waitstatus.h:106
TARGET_WAITKIND_SPURIOUS
Definition: waitstatus.h:77
gdb_tilde_expand.h
execv_argv::init_for_no_shell
void init_for_no_shell(const char *exec_file, const std::string &allargs)
Definition: fork-inferior.c:96
safe_strerror
char * safe_strerror(int)
Definition: mingw-strerror.c:32
TARGET_WAITKIND_EXITED
Definition: waitstatus.h:31
gdb_tilde_expand
std::string gdb_tilde_expand(const char *dir)
Definition: gdb_tilde_expand.c:72
TARGET_WAITKIND_VFORKED
Definition: waitstatus.h:52
shell_command
static void shell_command(const char *arg, int from_tty)
Definition: cli-cmds.c:760
gdb_signal_to_string
const char * gdb_signal_to_string(enum gdb_signal)
Definition: signals.c:68
TARGET_WAITKIND_LOADED
Definition: waitstatus.h:43
startup_with_shell
int startup_with_shell
Definition: infcmd.c:111
gdb.argv
argv
Definition: __init__.py:63
filestuff.h
vwarning
void void vwarning(const char *fmt, va_list args) ATTRIBUTE_PRINTF(1
TARGET_WAITKIND_IGNORE
Definition: waitstatus.h:88
TARGET_WAITKIND_STOPPED
Definition: waitstatus.h:35
error
void error(const char *fmt,...)
Definition: errors.c:38
execv_argv::m_argv
std::vector< const char * > m_argv
Definition: fork-inferior.c:78
minus_one_ptid
ptid_t minus_one_ptid
Definition: ptid.c:26
common-inferior.h
target_continue_no_signal
void target_continue_no_signal(ptid_t ptid)
Definition: target.c:3375
postfork_child_hook
void postfork_child_hook()
Definition: fork-child.c:103