/* Machine independent support for QNX Neutrino /proc (process file system)
for GDB. Written by Colin Burgess at QNX Software Systems Limited.
- Copyright (C) 2003-2015 Free Software Foundation, Inc.
+ Copyright (C) 2003-2018 Free Software Foundation, Inc.
Contributed by QNX Software Systems Ltd.
#include <sys/syspage.h>
#include <dirent.h>
#include <sys/netmgr.h>
+#include <sys/auxv.h>
+
#include "gdbcore.h"
#include "inferior.h"
#include "target.h"
#include "regcache.h"
#include "solib.h"
#include "inf-child.h"
+#include "common/filestuff.h"
+#include "common/scoped_fd.h"
#define NULL_PID 0
#define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
int ctl_fd;
-static void (*ofunc) ();
+static sighandler_t ofunc;
static procfs_run run;
static ptid_t do_attach (ptid_t ptid);
static int procfs_can_use_hw_breakpoint (struct target_ops *self,
- int, int, int);
+ enum bptype, int, int);
static int procfs_insert_hw_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
+ CORE_ADDR addr, int len,
+ enum target_hw_bp_type type,
struct expression *cond);
static int procfs_remove_hw_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
+ CORE_ADDR addr, int len,
+ enum target_hw_bp_type type,
struct expression *cond);
static int procfs_stopped_by_watchpoint (struct target_ops *ops);
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. */
-static char nto_procfs_path[PATH_MAX] = { "/proc" };
+static char *nodestr;
static unsigned nto_procfs_node = ND_LOCAL_NODE;
/* Return the current QNX Node, or error out. This is a simple
{
unsigned node;
- if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0)
+ if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0
+ || nodestr == NULL)
return ND_LOCAL_NODE;
- node = netmgr_strtond (nto_procfs_path, 0);
+ node = netmgr_strtond (nodestr, 0);
if (node == -1)
error (_("Lost the QNX node. Debug session probably over."));
static void
procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty)
{
- char *nodestr;
char *endstr;
char buffer[50];
- int fd, total_size;
+ int total_size;
procfs_sysinfo *sysinfo;
- struct cleanup *cleanups;
+ char nto_procfs_path[PATH_MAX];
/* Offer to kill previous inferiors before opening this target. */
target_preopen (from_tty);
/* Set the default node used for spawning to this one,
and only override it if there is a valid arg. */
+ xfree (nodestr);
+ nodestr = NULL;
+
nto_procfs_node = ND_LOCAL_NODE;
- nodestr = arg ? xstrdup (arg) : arg;
+ nodestr = (arg != NULL) ? xstrdup (arg) : NULL;
init_thread_list ();
*endstr = 0;
}
}
- snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "",
- "/proc");
- if (nodestr)
- xfree (nodestr);
+ snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s",
+ (nodestr != NULL) ? nodestr : "", "/proc");
- fd = open (nto_procfs_path, O_RDONLY);
- if (fd == -1)
+ scoped_fd fd (open (nto_procfs_path, O_RDONLY));
+ if (fd.get () == -1)
{
printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
safe_strerror (errno));
error (_("Invalid procfs arg"));
}
- cleanups = make_cleanup_close (fd);
sysinfo = (void *) buffer;
- if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
+ if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
{
printf_filtered ("Error getting size: %d (%s)\n", errno,
safe_strerror (errno));
{
total_size = sysinfo->total_size;
sysinfo = alloca (total_size);
- if (!sysinfo)
+ if (sysinfo == NULL)
{
printf_filtered ("Memory error: %d (%s)\n", errno,
safe_strerror (errno));
}
else
{
- if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
+ if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, total_size, 0)
+ != EOK)
{
printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
safe_strerror (errno));
}
}
}
- do_cleanups (cleanups);
inf_child_open_target (ops, arg, from_tty);
printf_filtered ("Debugging using %s\n", nto_procfs_path);
update_thread_private_data_name (struct thread_info *new_thread,
const char *newname)
{
- int newnamelen;
- struct private_thread_info *pti;
+ nto_thread_info *pti = get_nto_thread_info (new_thread);
gdb_assert (newname != NULL);
gdb_assert (new_thread != NULL);
- newnamelen = strlen (newname);
- if (!new_thread->private)
- {
- new_thread->private = xmalloc (offsetof (struct private_thread_info,
- name)
- + newnamelen + 1);
- memcpy (new_thread->private->name, newname, newnamelen + 1);
- }
- else if (strcmp (newname, new_thread->private->name) != 0)
+
+ if (pti)
{
- /* Reallocate if neccessary. */
- int oldnamelen = strlen (new_thread->private->name);
-
- if (oldnamelen < newnamelen)
- new_thread->private = xrealloc (new_thread->private,
- offsetof (struct private_thread_info,
- name)
- + newnamelen + 1);
- memcpy (new_thread->private->name, newname, newnamelen + 1);
+ pti = new nto_thread_info;
+ new_thread->priv.reset (pti);
}
+
+ pti->name = newname;
}
static void
update_thread_private_data (struct thread_info *new_thread,
pthread_t tid, int state, int flags)
{
- struct private_thread_info *pti;
procfs_info pidinfo;
struct _thread_name *tn;
procfs_threadctl tctl;
update_thread_private_data_name (new_thread, tn->name_buf);
- pti = (struct private_thread_info *) new_thread->private;
+ nto_thread_info *pti = get_nto_thread_info (new_thread);
pti->tid = tid;
pti->state = state;
pti->flags = flags;
closedir (dir);
}
-void
-procfs_pidlist (char *args, int from_tty)
+static void
+procfs_pidlist (const char *args, int from_tty)
{
DIR *dp = NULL;
struct dirent *dirp = NULL;
- char buf[512];
+ char buf[PATH_MAX];
procfs_info *pidinfo = NULL;
procfs_debuginfo *info = NULL;
procfs_status *status = NULL;
pid_t pid;
char name[512];
struct cleanup *cleanups;
+ char procfs_dir[PATH_MAX];
+
+ snprintf (procfs_dir, sizeof (procfs_dir), "%s%s",
+ (nodestr != NULL) ? nodestr : "", "/proc");
- dp = opendir (nto_procfs_path);
+ dp = opendir (procfs_dir);
if (dp == NULL)
{
fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
- nto_procfs_path, errno, safe_strerror (errno));
+ procfs_dir, errno, safe_strerror (errno));
return;
}
do
{
- int fd;
- struct cleanup *inner_cleanup;
-
/* Get the right pid and procfs path for the pid. */
do
{
do_cleanups (cleanups);
return;
}
- snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name);
+ snprintf (buf, sizeof (buf), "%s%s/%s/as",
+ (nodestr != NULL) ? nodestr : "",
+ "/proc", dirp->d_name);
pid = atoi (dirp->d_name);
}
while (pid == 0);
/* Open the procfs path. */
- fd = open (buf, O_RDONLY);
- if (fd == -1)
+ scoped_fd fd (open (buf, O_RDONLY));
+ if (fd.get () == -1)
{
fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
buf, errno, safe_strerror (errno));
- do_cleanups (cleanups);
- return;
+ continue;
}
- inner_cleanup = make_cleanup_close (fd);
pidinfo = (procfs_info *) buf;
- if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
+ if (devctl (fd.get (), DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
{
fprintf_unfiltered (gdb_stderr,
"devctl DCMD_PROC_INFO failed - %d (%s)\n",
num_threads = pidinfo->num_threads;
info = (procfs_debuginfo *) buf;
- if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)
+ if (devctl (fd.get (), DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0)
+ != EOK)
strcpy (name, "unavailable");
else
strcpy (name, info->path);
status = (procfs_status *) buf;
for (status->tid = 1; status->tid <= num_threads; status->tid++)
{
- if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK
- && status->tid != 0)
- break;
- if (status->tid != 0)
- printf_filtered ("%s - %d/%d\n", name, pid, status->tid);
+ const int err
+ = devctl (fd.get (), DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0);
+ printf_filtered ("%s - %d", name, pid);
+ if (err == EOK && status->tid != 0)
+ printf_filtered ("/%d\n", status->tid);
+ else
+ {
+ printf_filtered ("\n");
+ break;
+ }
}
-
- do_cleanups (inner_cleanup);
}
while (dirp != NULL);
return;
}
-void
-procfs_meminfo (char *args, int from_tty)
+static void
+procfs_meminfo (const char *args, int from_tty)
{
procfs_mapinfo *mapinfos = NULL;
static int num_mapinfos = 0;
return;
}
- mapinfos = xmalloc (num * sizeof (procfs_mapinfo));
+ mapinfos = XNEWVEC (procfs_mapinfo, num);
num_mapinfos = num;
mapinfo_p = mapinfos;
return;
}
- num = min (num, num_mapinfos);
+ num = std::min (num, num_mapinfos);
/* Run through the list of mapinfos, and store the data and text info
so we can print it at the bottom of the loop. */
printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
inf->attach_flag ? "attached" : "child",
- target_pid_to_str (inferior_ptid), nto_procfs_path);
+ target_pid_to_str (inferior_ptid),
+ (nodestr != NULL) ? nodestr : "local node");
+}
+
+/* Target to_pid_to_exec_file implementation. */
+
+static char *
+procfs_pid_to_exec_file (struct target_ops *ops, const int pid)
+{
+ int proc_fd;
+ static char proc_path[PATH_MAX];
+ ssize_t rd;
+
+ /* Read exe file name. */
+ snprintf (proc_path, sizeof (proc_path), "%s/proc/%d/exefile",
+ (nodestr != NULL) ? nodestr : "", pid);
+ proc_fd = open (proc_path, O_RDONLY);
+ if (proc_fd == -1)
+ return NULL;
+
+ rd = read (proc_fd, proc_path, sizeof (proc_path) - 1);
+ close (proc_fd);
+ if (rd <= 0)
+ {
+ proc_path[0] = '\0';
+ return NULL;
+ }
+ proc_path[rd] = '\0';
+ return proc_path;
}
/* Attach to process PID, then initialize for debugging it. */
struct sigevent event;
char path[PATH_MAX];
- snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path,
- ptid_get_pid (ptid));
+ snprintf (path, PATH_MAX - 1, "%s%s/%d/as",
+ (nodestr != NULL) ? nodestr : "", "/proc", ptid_get_pid (ptid));
ctl_fd = open (path, O_RDWR);
if (ctl_fd == -1)
error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
static void
interrupt_query (void)
{
- target_terminal_ours ();
-
if (query (_("Interrupted while waiting for the program.\n\
Give up (and stop debugging it)? ")))
{
- target_mourn_inferior ();
+ target_mourn_inferior (inferior_ptid);
quit ();
}
-
- target_terminal_inferior ();
}
/* The user typed ^C twice. */
static void
-nto_interrupt_twice (int signo)
+nto_handle_sigint_twice (int signo)
{
signal (signo, ofunc);
interrupt_query ();
- signal (signo, nto_interrupt_twice);
+ signal (signo, nto_handle_sigint_twice);
}
static void
-nto_interrupt (int signo)
+nto_handle_sigint (int signo)
{
/* If this doesn't work, try more severe steps. */
- signal (signo, nto_interrupt_twice);
+ signal (signo, nto_handle_sigint_twice);
- target_stop (inferior_ptid);
+ target_interrupt ();
}
static ptid_t
devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
while (!(status.flags & _DEBUG_FLAG_ISTOP))
{
- ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
+ ofunc = signal (SIGINT, nto_handle_sigint);
sigwaitinfo (&set, &info);
signal (SIGINT, ofunc);
devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
}
+ nto_inferior_data (NULL)->stopped_flags = status.flags;
+ nto_inferior_data (NULL)->stopped_pc = status.ip;
+
if (status.flags & _DEBUG_FLAG_SSTEP)
{
ourstatus->kind = TARGET_WAITKIND_STOPPED;
reg;
int regsize;
- procfs_set_thread (inferior_ptid);
+ procfs_set_thread (regcache_get_ptid (regcache));
if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK)
nto_supply_gregset (regcache, (char *) ®.greg);
if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size)
{
case TARGET_OBJECT_MEMORY:
return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
+ case TARGET_OBJECT_AUXV:
+ if (readbuf != NULL)
+ {
+ int err;
+ CORE_ADDR initial_stack;
+ debug_process_t procinfo;
+ /* For 32-bit architecture, size of auxv_t is 8 bytes. */
+ const unsigned int sizeof_auxv_t = sizeof (auxv_t);
+ const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t;
+ int tempread;
+ gdb_byte *const tempbuf = alloca (sizeof_tempbuf);
+
+ if (tempbuf == NULL)
+ return TARGET_XFER_E_IO;
+
+ err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo,
+ sizeof procinfo, 0);
+ if (err != EOK)
+ return TARGET_XFER_E_IO;
+
+ initial_stack = procinfo.initial_stack;
+
+ /* procfs is always 'self-hosted', no byte-order manipulation. */
+ tempread = nto_read_auxv_from_initial_stack (initial_stack, tempbuf,
+ sizeof_tempbuf,
+ sizeof (auxv_t));
+ tempread = std::min (tempread, len) - offset;
+ memcpy (readbuf, tempbuf + offset, tempread);
+ *xfered_len = tempread;
+ return tempread ? TARGET_XFER_OK : TARGET_XFER_EOF;
+ }
+ /* Fallthru */
default:
return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
- readbuf, writebuf, offset, len);
+ readbuf, writebuf, offset, len,
+ xfered_len);
}
}
on signals, etc. We'd better not have left any breakpoints
in the program or it'll die when it hits one. */
static void
-procfs_detach (struct target_ops *ops, const char *args, int from_tty)
+procfs_detach (struct target_ops *ops, inferior *inf, int from_tty)
{
- int siggnal = 0;
int pid;
- 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 (inferior_ptid));
- gdb_flush (gdb_stdout);
- }
- if (args)
- siggnal = atoi (args);
+ target_announce_detach ();
if (siggnal)
- SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, siggnal, 0, 0);
+ SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, 0, 0, 0);
close (ctl_fd);
ctl_fd = -1;
static int
procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
- struct bp_target_info *bp_tgt)
+ struct bp_target_info *bp_tgt,
+ enum remove_bp_reason reason)
{
return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
}
}
static void
-procfs_create_inferior (struct target_ops *ops, char *exec_file,
- char *allargs, char **env, int from_tty)
+procfs_create_inferior (struct target_ops *ops, const char *exec_file,
+ const std::string &allargs,
+ char **env, int from_tty)
{
struct inheritance inherit;
pid_t pid;
const char *inferior_io_terminal = get_inferior_io_terminal ();
struct inferior *inf;
- argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
+ argv = xmalloc ((allargs.size () / (unsigned) 2 + 2) *
sizeof (*argv));
argv[0] = get_exec_file (1);
if (!argv[0])
return;
}
- args = xstrdup (allargs);
- breakup_args (args, exec_file ? &argv[1] : &argv[0]);
+ args = xstrdup (allargs.c_str ());
+ breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]);
argv = nto_parse_redirection (argv, &in, &out, &err);
}
if (!target_is_pushed (ops))
push_target (ops);
- target_terminal_init ();
+ target_terminal::init ();
if (exec_bfd != NULL
|| (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
}
static void
-procfs_stop (struct target_ops *self, ptid_t ptid)
+procfs_interrupt (struct target_ops *self)
{
devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
}
static void
procfs_kill_inferior (struct target_ops *ops)
{
- target_mourn_inferior ();
+ target_mourn_inferior (inferior_ptid);
}
/* Fill buf with regset and return devctl cmd to do the setting. Return
return dev_set;
}
-void
+static void
procfs_store_registers (struct target_ops *ops,
struct regcache *regcache, int regno)
{
unsigned off;
int len, regset, regsize, dev_set, err;
char *data;
+ ptid_t ptid = regcache_get_ptid (regcache);
- if (ptid_equal (inferior_ptid, null_ptid))
+ if (ptid_equal (ptid, null_ptid))
return;
- procfs_set_thread (inferior_ptid);
+ procfs_set_thread (ptid);
if (regno == -1)
{
if (dev_set == -1)
return;
- len = nto_register_area (get_regcache_arch (regcache),
+ len = nto_register_area (regcache->arch (),
regno, regset, &off);
if (len < 1)
}
}
-static struct tidinfo *
-procfs_thread_info (pid_t pid, short tid)
-{
-/* NYI */
- return NULL;
-}
-
static char *
procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
t->to_thread_alive = procfs_thread_alive;
t->to_update_thread_list = procfs_update_thread_list;
t->to_pid_to_str = procfs_pid_to_str;
- t->to_stop = procfs_stop;
+ t->to_interrupt = procfs_interrupt;
t->to_have_continuable_watchpoint = 1;
t->to_extra_thread_info = nto_extra_thread_info;
+ t->to_pid_to_exec_file = procfs_pid_to_exec_file;
nto_native_ops = t;
static int
-procfs_hw_watchpoint (int addr, int len, int type)
+procfs_hw_watchpoint (int addr, int len, enum target_hw_bp_type type)
{
procfs_break brk;
switch (type)
{
- case 1: /* Read. */
+ case hw_read:
brk.type = _DEBUG_BREAK_RD;
break;
- case 2: /* Read/Write. */
+ case hw_access:
brk.type = _DEBUG_BREAK_RW;
break;
default: /* Modify. */
static int
procfs_can_use_hw_breakpoint (struct target_ops *self,
- int type, int cnt, int othertype)
+ enum bptype type,
+ int cnt, int othertype)
{
return 1;
}
static int
procfs_remove_hw_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
+ CORE_ADDR addr, int len,
+ enum target_hw_bp_type type,
struct expression *cond)
{
return procfs_hw_watchpoint (addr, -1, type);
static int
procfs_insert_hw_watchpoint (struct target_ops *self,
- CORE_ADDR addr, int len, int type,
+ CORE_ADDR addr, int len,
+ enum target_hw_bp_type type,
struct expression *cond)
{
return procfs_hw_watchpoint (addr, len, type);
static int
procfs_stopped_by_watchpoint (struct target_ops *ops)
{
- return 0;
+ /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are
+ stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode;
+ future gdb versions will likely run in 'non-stop' mode in which case
+ we will have to store/examine statuses per thread in question.
+ Until then, this will work fine. */
+
+ struct inferior *inf = current_inferior ();
+ struct nto_inferior_data *inf_data;
+
+ gdb_assert (inf != NULL);
+
+ inf_data = nto_inferior_data (inf);
+
+ return inf_data->stopped_flags
+ & (_DEBUG_FLAG_TRACE_RD
+ | _DEBUG_FLAG_TRACE_WR
+ | _DEBUG_FLAG_TRACE_MODIFY);
}
projects / deliverable / binutils-gdb.git / blobdiff