#include "defs.h"
#include "frame.h"
#include "inferior.h"
#include "target.h"
#include "gdbcore.h"
#include "command.h"
#include "gdb_stat.h"
#include <signal.h>
#include <sys/types.h>
#include <fcntl.h>
#include "event-loop.h"
#include "observer.h"
#include "gdb_wait.h"
#include "inflow.h"
extern struct symtab_and_line *child_enable_exception_callback (enum
exception_event_kind,
int);
extern struct symtabs_and_lines *
child_find_exception_catchpoints (enum exception_event_kind,
struct objfile *);
extern struct exception_event_record
*child_get_current_exception_event (void);
extern void _initialize_inftarg (void);
static void child_prepare_to_store (void);
#ifndef CHILD_WAIT
static ptid_t child_wait (ptid_t, struct target_waitstatus *, gdb_client_data client_data);
#endif
static void child_open (char *, int);
static void child_files_info (struct target_ops *);
static void child_detach (char *, int);
static void child_attach (char *, int);
#if !defined(CHILD_POST_ATTACH)
extern void child_post_attach (int);
#endif
static void ptrace_me (void);
static void ptrace_him (int);
static void child_create_inferior (char *, char *, char **, int);
static void child_mourn_inferior (void);
static int child_can_run (void);
static void child_stop (void);
#ifndef CHILD_THREAD_ALIVE
int child_thread_alive (ptid_t);
#endif
void init_child_ops (void);
extern char **environ;
int child_suppress_run = 0;
#ifndef CHILD_WAIT
static ptid_t
child_wait (ptid_t ptid, struct target_waitstatus *ourstatus, gdb_client_data client_data)
{
int save_errno;
int status;
char *execd_pathname = NULL;
int exit_status;
int related_pid;
int syscall_id;
enum target_waitkind kind;
int pid;
do
{
set_sigint_trap ();
set_sigio_trap ();
pid = wait (&status);
save_errno = errno;
clear_sigio_trap ();
clear_sigint_trap ();
if (pid == -1)
{
if (save_errno == EINTR)
continue;
fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing: %s.\n",
safe_strerror (save_errno));
ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
return pid_to_ptid (-1);
}
if (target_has_exited (pid, status, &exit_status))
{
continue;
}
if (!target_thread_alive (pid_to_ptid (pid)))
{
ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
return pid_to_ptid (pid);
}
} while (pid != PIDGET (inferior_ptid));
store_waitstatus (ourstatus, status);
return pid_to_ptid (pid);
}
#endif
#ifndef CHILD_THREAD_ALIVE
int
child_thread_alive (ptid_t ptid)
{
pid_t pid = PIDGET (ptid);
return (kill (pid, 0) != -1);
}
#endif
static void
child_attach (char *args, int from_tty)
{
char *exec_file;
int pid;
char *dummy;
if (!args)
error_no_arg (_("process-id to attach"));
dummy = args;
pid = strtol (args, &dummy, 0);
if ((pid == 0) && (args == dummy))
error (_("Illegal process-id: %s."), args);
if (pid == getpid ())
error (_("I refuse to debug myself!"));
if (from_tty)
{
exec_file = (char *) get_exec_file (0);
if (exec_file)
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
else
printf_unfiltered (_("Attaching to %s\n"),
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
}
attach (pid);
inferior_ptid = pid_to_ptid (pid);
push_target (&deprecated_child_ops);
observer_notify_inferior_created (¤t_target, from_tty);
}
#if !defined(CHILD_POST_ATTACH)
void
child_post_attach (int pid)
{
}
#endif
static void
child_detach (char *args, int from_tty)
{
int siggnal = 0;
int pid = PIDGET (inferior_ptid);
if (from_tty)
{
char *exec_file = get_exec_file (0);
if (exec_file == 0)
exec_file = "";
printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file,
target_pid_to_str (pid_to_ptid (pid)));
gdb_flush (gdb_stdout);
}
if (args)
siggnal = atoi (args);
detach (siggnal);
inferior_ptid = null_ptid;
unpush_target (&deprecated_child_ops);
}
static void
child_prepare_to_store (void)
{
#ifdef CHILD_PREPARE_TO_STORE
CHILD_PREPARE_TO_STORE ();
#endif
}
static void
child_files_info (struct target_ops *ignore)
{
printf_unfiltered (_("\tUsing the running image of %s %s.\n"),
attach_flag ? "attached" : "child", target_pid_to_str (inferior_ptid));
}
static void
child_open (char *arg, int from_tty)
{
error (_("Use the \"run\" command to start a Unix child process."));
}
static void
ptrace_me (void)
{
call_ptrace (0, 0, (PTRACE_TYPE_ARG3) 0, 0);
}
static void
ptrace_him (int pid)
{
push_target (&deprecated_child_ops);
target_acknowledge_created_inferior (pid);
startup_inferior ();
target_post_startup_inferior (pid_to_ptid (pid));
}
static void
child_create_inferior (char *exec_file, char *allargs, char **env,
int from_tty)
{
fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him, NULL, NULL);
observer_notify_inferior_created (¤t_target, from_tty);
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
}
#if !defined(CHILD_POST_STARTUP_INFERIOR)
void
child_post_startup_inferior (ptid_t ptid)
{
}
#endif
#if !defined(CHILD_ACKNOWLEDGE_CREATED_INFERIOR)
void
child_acknowledge_created_inferior (int pid)
{
}
#endif
#if !defined(CHILD_INSERT_FORK_CATCHPOINT)
void
child_insert_fork_catchpoint (int pid)
{
}
#endif
#if !defined(CHILD_REMOVE_FORK_CATCHPOINT)
int
child_remove_fork_catchpoint (int pid)
{
return 0;
}
#endif
#if !defined(CHILD_INSERT_VFORK_CATCHPOINT)
void
child_insert_vfork_catchpoint (int pid)
{
}
#endif
#if !defined(CHILD_REMOVE_VFORK_CATCHPOINT)
int
child_remove_vfork_catchpoint (int pid)
{
return 0;
}
#endif
#if !defined(CHILD_FOLLOW_FORK)
int
child_follow_fork (int follow_child)
{
return 0;
}
#endif
#if !defined(CHILD_INSERT_EXEC_CATCHPOINT)
void
child_insert_exec_catchpoint (int pid)
{
}
#endif
#if !defined(CHILD_REMOVE_EXEC_CATCHPOINT)
int
child_remove_exec_catchpoint (int pid)
{
return 0;
}
#endif
#if !defined(CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL)
int
child_reported_exec_events_per_exec_call (void)
{
return 1;
}
#endif
#if !defined(CHILD_HAS_EXITED)
int
child_has_exited (int pid, int wait_status, int *exit_status)
{
if (WIFEXITED (wait_status))
{
*exit_status = WEXITSTATUS (wait_status);
return 1;
}
if (WIFSIGNALED (wait_status))
{
*exit_status = 0;
return 1;
}
return 0;
}
#endif
static void
child_mourn_inferior (void)
{
unpush_target (&deprecated_child_ops);
generic_mourn_inferior ();
}
static int
child_can_run (void)
{
return !child_suppress_run;
}
static void
child_stop (void)
{
kill (-inferior_process_group, SIGINT);
}
#if !defined(CHILD_ENABLE_EXCEPTION_CALLBACK)
struct symtabs_and_lines *
child_find_exception_catchpoints (enum exception_event_kind kind,
struct objfile *objfile)
{
return (struct symtabs_and_lines *) NULL;
}
struct symtab_and_line *
child_enable_exception_callback (enum exception_event_kind kind, int enable)
{
return (struct symtab_and_line *) NULL;
}
#endif
#if !defined(CHILD_GET_CURRENT_EXCEPTION_EVENT)
struct exception_event_record *
child_get_current_exception_event (void)
{
return (struct exception_event_record *) NULL;
}
#endif
#if !defined(CHILD_PID_TO_EXEC_FILE)
char *
child_pid_to_exec_file (int pid)
{
return NULL;
}
#endif
char *
child_core_file_to_sym_file (char *core)
{
return NULL;
}
static LONGEST
child_xfer_partial (struct target_ops *ops, enum target_object object,
const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
{
switch (object)
{
case TARGET_OBJECT_MEMORY:
if (readbuf)
return child_xfer_memory (offset, readbuf, len, 0,
NULL, ops);
if (writebuf)
return child_xfer_memory (offset, (void *) writebuf, len, 1,
NULL, ops);
return -1;
case TARGET_OBJECT_UNWIND_TABLE:
#ifndef NATIVE_XFER_UNWIND_TABLE
#define NATIVE_XFER_UNWIND_TABLE(OPS,OBJECT,ANNEX,WRITEBUF,READBUF,OFFSET,LEN) (-1)
#endif
return NATIVE_XFER_UNWIND_TABLE (ops, object, annex, readbuf, writebuf,
offset, len);
case TARGET_OBJECT_AUXV:
#ifndef NATIVE_XFER_AUXV
#define NATIVE_XFER_AUXV(OPS,OBJECT,ANNEX,WRITEBUF,READBUF,OFFSET,LEN) (-1)
#endif
return NATIVE_XFER_AUXV (ops, object, annex, readbuf, writebuf,
offset, len);
default:
return -1;
}
}
#if !defined(CHILD_PID_TO_STR)
char *
child_pid_to_str (ptid_t ptid)
{
return normal_pid_to_str (ptid);
}
#endif
void
init_child_ops (void)
{
deprecated_child_ops.to_shortname = "child";
deprecated_child_ops.to_longname = "Unix child process";
deprecated_child_ops.to_doc = "Unix child process (started by the \"run\" command).";
deprecated_child_ops.to_open = child_open;
deprecated_child_ops.to_attach = child_attach;
deprecated_child_ops.to_post_attach = child_post_attach;
deprecated_child_ops.to_detach = child_detach;
deprecated_child_ops.to_resume = child_resume;
deprecated_child_ops.to_wait = child_wait;
deprecated_child_ops.to_fetch_registers = fetch_inferior_registers;
deprecated_child_ops.to_store_registers = store_inferior_registers;
deprecated_child_ops.to_prepare_to_store = child_prepare_to_store;
deprecated_child_ops.deprecated_xfer_memory = child_xfer_memory;
deprecated_child_ops.to_xfer_partial = child_xfer_partial;
deprecated_child_ops.to_files_info = child_files_info;
deprecated_child_ops.to_insert_breakpoint = memory_insert_breakpoint;
deprecated_child_ops.to_remove_breakpoint = memory_remove_breakpoint;
deprecated_child_ops.to_terminal_init = terminal_init_inferior;
deprecated_child_ops.to_terminal_inferior = terminal_inferior;
deprecated_child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
deprecated_child_ops.to_terminal_save_ours = terminal_save_ours;
deprecated_child_ops.to_terminal_ours = terminal_ours;
deprecated_child_ops.to_terminal_info = child_terminal_info;
deprecated_child_ops.to_kill = kill_inferior;
deprecated_child_ops.to_create_inferior = child_create_inferior;
deprecated_child_ops.to_post_startup_inferior = child_post_startup_inferior;
deprecated_child_ops.to_acknowledge_created_inferior = child_acknowledge_created_inferior;
deprecated_child_ops.to_insert_fork_catchpoint = child_insert_fork_catchpoint;
deprecated_child_ops.to_remove_fork_catchpoint = child_remove_fork_catchpoint;
deprecated_child_ops.to_insert_vfork_catchpoint = child_insert_vfork_catchpoint;
deprecated_child_ops.to_remove_vfork_catchpoint = child_remove_vfork_catchpoint;
deprecated_child_ops.to_follow_fork = child_follow_fork;
deprecated_child_ops.to_insert_exec_catchpoint = child_insert_exec_catchpoint;
deprecated_child_ops.to_remove_exec_catchpoint = child_remove_exec_catchpoint;
deprecated_child_ops.to_reported_exec_events_per_exec_call = child_reported_exec_events_per_exec_call;
deprecated_child_ops.to_has_exited = child_has_exited;
deprecated_child_ops.to_mourn_inferior = child_mourn_inferior;
deprecated_child_ops.to_can_run = child_can_run;
deprecated_child_ops.to_thread_alive = child_thread_alive;
deprecated_child_ops.to_pid_to_str = child_pid_to_str;
deprecated_child_ops.to_stop = child_stop;
deprecated_child_ops.to_enable_exception_callback = child_enable_exception_callback;
deprecated_child_ops.to_find_exception_catchpoints = child_find_exception_catchpoints;
deprecated_child_ops.to_get_current_exception_event = child_get_current_exception_event;
deprecated_child_ops.to_pid_to_exec_file = child_pid_to_exec_file;
deprecated_child_ops.to_stratum = process_stratum;
deprecated_child_ops.to_has_all_memory = 1;
deprecated_child_ops.to_has_memory = 1;
deprecated_child_ops.to_has_stack = 1;
deprecated_child_ops.to_has_registers = 1;
deprecated_child_ops.to_has_execution = 1;
deprecated_child_ops.to_magic = OPS_MAGIC;
}
void
_initialize_inftarg (void)
{
#ifdef HAVE_OPTIONAL_PROC_FS
char procname[32];
int fd;
#ifndef PROC_NAME_FMT
#define PROC_NAME_FMT "/proc/%05d"
#endif
sprintf (procname, PROC_NAME_FMT, getpid ());
fd = open (procname, O_RDONLY);
if (fd >= 0)
{
close (fd);
return;
}
#endif
init_child_ops ();
add_target (&deprecated_child_ops);
}