static procfs_run run;
-static void procfs_open (char *, int);
-
static ptid_t do_attach (ptid_t ptid);
static int procfs_can_use_hw_breakpoint (struct target_ops *self,
static int procfs_stopped_by_watchpoint (struct target_ops *ops);
-/* These two globals are only ever set in procfs_open(), but are
+/* These two globals are only ever set in procfs_open_1, but are
referenced elsewhere. 'nto_procfs_node' is a flag used to say
whether we are local, or we should get the current node descriptor
for the remote QNX node. */
return GDB_OSABI_QNXNTO;
}
-/* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
- For QNX6 (nto), the only valid arg will be a QNX node string,
- eg: "/net/some_node". If arg is not a valid QNX node, we will
- default to local. */
+/* This is called when we call 'target native' or 'target procfs
+ <arg>' from the (gdb) prompt. For QNX6 (nto), the only valid arg
+ will be a QNX node string, eg: "/net/some_node". If arg is not a
+ valid QNX node, we will default to local. */
static void
-procfs_open (char *arg, int from_tty)
+procfs_open_1 (struct target_ops *ops, char *arg, int from_tty)
{
char *nodestr;
char *endstr;
procfs_sysinfo *sysinfo;
struct cleanup *cleanups;
+ /* Offer to kill previous inferiors before opening this target. */
+ target_preopen (from_tty);
+
nto_is_nto_target = procfs_is_nto_target;
/* Set the default node used for spawning to this one,
}
}
do_cleanups (cleanups);
+
+ inf_child_open_target (ops, arg, from_tty);
printf_filtered ("Debugging using %s\n", nto_procfs_path);
}
/* Attach to process PID, then initialize for debugging it. */
static void
-procfs_attach (struct target_ops *ops, char *args, int from_tty)
+procfs_attach (struct target_ops *ops, const char *args, int from_tty)
{
char *exec_file;
int pid;
inferior_appeared (inf, pid);
inf->attach_flag = 1;
- push_target (ops);
+ if (!target_is_pushed (ops))
+ push_target (ops);
procfs_find_new_threads (ops);
}
inferior_ptid = null_ptid;
detach_inferior (pid);
init_thread_list ();
- unpush_target (ops); /* Pop out of handling an inferior. */
+ inf_child_maybe_unpush_target (ops);
}
static int
}
inferior_ptid = null_ptid;
init_thread_list ();
- unpush_target (ops);
- generic_mourn_inferior ();
+ inf_child_mourn_inferior (ops);
}
/* This function breaks up an argument string into an argument
/* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
errn, strerror(errn) ); */
}
- push_target (ops);
+ if (!target_is_pushed (ops))
+ push_target (ops);
target_terminal_init ();
if (exec_bfd != NULL
return buf;
}
-/* Create a nto-procfs target. */
+/* to_can_run implementation for "target procfs". Note this really
+ means "can this target be the default run target", which there can
+ be only one, and we make it be "target native" like other ports.
+ "target procfs <node>" wouldn't make sense as default run target, as
+ it needs <node>. */
+
+static int
+procfs_can_run (struct target_ops *self)
+{
+ return 0;
+}
+
+/* "target procfs". */
+static struct target_ops nto_procfs_ops;
+
+/* "target native". */
+static struct target_ops *nto_native_ops;
+
+/* to_open implementation for "target procfs". */
-static struct target_ops *
-procfs_target (void)
+static void
+procfs_open (char *arg, int from_tty)
+{
+ procfs_open_1 (&nto_procfs_ops, arg, from_tty);
+}
+
+/* to_open implementation for "target native". */
+
+static void
+procfs_native_open (char *arg, int from_tty)
+{
+ procfs_open_1 (nto_native_ops, arg, from_tty);
+}
+
+/* Create the "native" and "procfs" targets. */
+
+static void
+init_procfs_targets (void)
{
struct target_ops *t = inf_child_target ();
- t->to_shortname = "procfs";
- t->to_longname = "QNX Neutrino procfs child process";
- t->to_doc
- = "QNX Neutrino procfs child process (started by the \"run\" command).\n\
- target procfs <node>";
- t->to_open = procfs_open;
+ /* Leave to_shortname as "native". */
+ t->to_longname = "QNX Neutrino local process";
+ t->to_doc = "QNX Neutrino local process (started by the \"run\" command).";
+ t->to_open = procfs_native_open;
t->to_attach = procfs_attach;
t->to_post_attach = procfs_post_attach;
t->to_detach = procfs_detach;
t->to_have_continuable_watchpoint = 1;
t->to_extra_thread_info = nto_extra_thread_info;
- return t;
+ nto_native_ops = t;
+
+ /* Register "target native". This is the default run target. */
+ add_target (t);
+
+ /* Register "target procfs <node>". */
+ nto_procfs_ops = *t;
+ nto_procfs_ops.to_shortname = "procfs";
+ nto_procfs_ops.to_can_run = procfs_can_run;
+ t->to_longname = "QNX Neutrino local or remote process";
+ t->to_doc = "QNX Neutrino process. target procfs <node>";
+ t->to_open = procfs_open;
+
+ add_target (&nto_procfs_ops);
}
#define OSTYPE_NTO 1
_initialize_procfs (void)
{
sigset_t set;
- struct target_ops *t;
- t = procfs_target ();
- add_target (t);
+ init_procfs_targets ();
/* We use SIGUSR1 to gain control after we block waiting for a process.
We use sigwaitevent to wait. */