Subversion Repositories openrisc_2011-10-31

/* Machine independent support for QNX Neutrino /proc (process file system)

   for GDB.  Written by Colin Burgess at QNX Software Systems Limited.

   Copyright (C) 2003, 2006, 2007, 2008, 2009, 2010

   Free Software Foundation, Inc.

   Contributed by QNX Software Systems Ltd.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"

#include <fcntl.h>

#include <spawn.h>

#include <sys/debug.h>

#include <sys/procfs.h>

#include <sys/neutrino.h>

#include <sys/syspage.h>

#include "gdb_dirent.h"

#include <sys/netmgr.h>

#include "exceptions.h"

#include "gdb_string.h"

#include "gdbcore.h"

#include "inferior.h"

#include "target.h"

#include "objfiles.h"

#include "gdbthread.h"

#include "nto-tdep.h"

#include "command.h"

#include "regcache.h"

#include "solib.h"

#define NULL_PID                0

#define _DEBUG_FLAG_TRACE       (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\

                _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)

static struct target_ops procfs_ops;

int ctl_fd;

static void (*ofunc) ();

static procfs_run run;

static void procfs_open (char *, int);

static int procfs_can_run (void);

static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,

                               struct mem_attrib *attrib,

                               struct target_ops *);

static void notice_signals (void);

static void init_procfs_ops (void);

static ptid_t do_attach (ptid_t ptid);

static int procfs_can_use_hw_breakpoint (int, int, int);

static int procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type);

static int procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type);

static int procfs_stopped_by_watchpoint (void);

/* These two globals are only ever set in procfs_open(), 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.  */

static char nto_procfs_path[PATH_MAX] = { "/proc" };

static unsigned nto_procfs_node = ND_LOCAL_NODE;

/* Return the current QNX Node, or error out.  This is a simple

   wrapper for the netmgr_strtond() function.  The reason this

   is required is because QNX node descriptors are transient so

   we have to re-acquire them every time.  */

static unsigned

nto_node (void)

{

  unsigned node;

  if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0)

    return ND_LOCAL_NODE;

  node = netmgr_strtond (nto_procfs_path, 0);

  if (node == -1)

    error (_("Lost the QNX node.  Debug session probably over."));

  return (node);

}

static enum gdb_osabi

procfs_is_nto_target (bfd *abfd)

{

  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.  */

static void

procfs_open (char *arg, int from_tty)

{

  char *nodestr;

  char *endstr;

  char buffer[50];

  int fd, total_size;

  procfs_sysinfo *sysinfo;

  struct cleanup *cleanups;

  nto_is_nto_target = procfs_is_nto_target;

  /* Set the default node used for spawning to this one,

     and only override it if there is a valid arg.  */

  nto_procfs_node = ND_LOCAL_NODE;

  nodestr = arg ? xstrdup (arg) : arg;

  init_thread_list ();

  if (nodestr)

    {

      nto_procfs_node = netmgr_strtond (nodestr, &endstr);

      if (nto_procfs_node == -1)

        {

          if (errno == ENOTSUP)

            printf_filtered ("QNX Net Manager not found.\n");

          printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr,

                           errno, safe_strerror (errno));

          xfree (nodestr);

          nodestr = NULL;

          nto_procfs_node = ND_LOCAL_NODE;

        }

      else if (*endstr)

        {

          if (*(endstr - 1) == '/')

            *(endstr - 1) = 0;

          else

            *endstr = 0;

        }

    }

  snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "",

            "/proc");

  if (nodestr)

    xfree (nodestr);

  fd = open (nto_procfs_path, O_RDONLY);

  if (fd == -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)

    {

      printf_filtered ("Error getting size: %d (%s)\n", errno,

                       safe_strerror (errno));

      error (_("Devctl failed."));

    }

  else

    {

      total_size = sysinfo->total_size;

      sysinfo = alloca (total_size);

      if (!sysinfo)

        {

          printf_filtered ("Memory error: %d (%s)\n", errno,

                           safe_strerror (errno));

          error (_("alloca failed."));

        }

      else

        {

          if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)

            {

              printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,

                               safe_strerror (errno));

              error (_("Devctl failed."));

            }

          else

            {

              if (sysinfo->type !=

                  nto_map_arch_to_cputype (gdbarch_bfd_arch_info

                                           (target_gdbarch)->arch_name))

                error (_("Invalid target CPU."));

            }

        }

    }

  do_cleanups (cleanups);

  printf_filtered ("Debugging using %s\n", nto_procfs_path);

}

static void

procfs_set_thread (ptid_t ptid)

{

  pid_t tid;

  tid = ptid_get_tid (ptid);

  devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);

}

/*  Return nonzero if the thread TH is still alive.  */

static int

procfs_thread_alive (struct target_ops *ops, ptid_t ptid)

{

  pid_t tid;

  pid_t pid;

  procfs_status status;

  int err;

  tid = ptid_get_tid (ptid);

  pid = ptid_get_pid (ptid);

  if (kill (pid, 0) == -1)

    return 0;

  status.tid = tid;

  if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS,

                     &status, sizeof (status), 0)) != EOK)

    return 0;

  /* Thread is alive or dead but not yet joined,

     or dead and there is an alive (or dead unjoined) thread with

     higher tid.

     If the tid is not the same as requested, requested tid is dead.  */

  return (status.tid == tid) && (status.state != STATE_DEAD);

}

static void

update_thread_private_data_name (struct thread_info *new_thread,

                                 const char *newname)

{

  int newnamelen;

  struct private_thread_info *pti;

  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)

    {

      /* 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);

    }

}

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;

#if _NTO_VERSION > 630

  gdb_assert (new_thread != NULL);

  if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo,

              sizeof(pidinfo), 0) != EOK)

    return;

  memset (&tctl, 0, sizeof (tctl));

  tctl.cmd = _NTO_TCTL_NAME;

  tn = (struct _thread_name *) (&tctl.data);

  /* Fetch name for the given thread.  */

  tctl.tid = tid;

  tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn);

  tn->new_name_len = -1; /* Getting, not setting.  */

  if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK)

    tn->name_buf[0] = '\0';

  tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0';

  update_thread_private_data_name (new_thread, tn->name_buf);

  pti = (struct private_thread_info *) new_thread->private;

  pti->tid = tid;

  pti->state = state;

  pti->flags = flags;

#endif /* _NTO_VERSION */

}

void

procfs_find_new_threads (struct target_ops *ops)

{

  procfs_status status;

  pid_t pid;

  ptid_t ptid;

  pthread_t tid;

  struct thread_info *new_thread;

  if (ctl_fd == -1)

    return;

  pid = ptid_get_pid (inferior_ptid);

  status.tid = 1;

  for (tid = 1;; ++tid)

    {

      if (status.tid == tid

          && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)

              != EOK))

        break;

      if (status.tid != tid)

        /* The reason why this would not be equal is that devctl might have

           returned different tid, meaning the requested tid no longer exists

           (e.g. thread exited).  */

        continue;

      ptid = ptid_build (pid, 0, tid);

      new_thread = find_thread_ptid (ptid);

      if (!new_thread)

        new_thread = add_thread (ptid);

      update_thread_private_data (new_thread, tid, status.state, 0);

      status.tid++;

    }

  return;

}

static void

do_closedir_cleanup (void *dir)

{

  closedir (dir);

}

void

procfs_pidlist (char *args, int from_tty)

{

  DIR *dp = NULL;

  struct dirent *dirp = NULL;

  char buf[512];

  procfs_info *pidinfo = NULL;

  procfs_debuginfo *info = NULL;

  procfs_status *status = NULL;

  pid_t num_threads = 0;

  pid_t pid;

  char name[512];

  struct cleanup *cleanups;

  dp = opendir (nto_procfs_path);

  if (dp == NULL)

    {

      fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",

                          nto_procfs_path, errno, safe_strerror (errno));

      return;

    }

  cleanups = make_cleanup (do_closedir_cleanup, dp);

  /* Start scan at first pid.  */

  rewinddir (dp);

  do

    {

      int fd;

      struct cleanup *inner_cleanup;

      /* Get the right pid and procfs path for the pid.  */

      do

        {

          dirp = readdir (dp);

          if (dirp == NULL)

            {

              do_cleanups (cleanups);

              return;

            }

          snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name);

          pid = atoi (dirp->d_name);

        }

      while (pid == 0);

      /* Open the procfs path. */

      fd = open (buf, O_RDONLY);

      if (fd == -1)

        {

          fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",

                              buf, errno, safe_strerror (errno));

          do_cleanups (cleanups);

          return;

        }

      inner_cleanup = make_cleanup_close (fd);

      pidinfo = (procfs_info *) buf;

      if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)

        {

          fprintf_unfiltered (gdb_stderr,

                              "devctl DCMD_PROC_INFO failed - %d (%s)\n",

                              errno, safe_strerror (errno));

          break;

        }

      num_threads = pidinfo->num_threads;

      info = (procfs_debuginfo *) buf;

      if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)

        strcpy (name, "unavailable");

      else

        strcpy (name, info->path);

      /* Collect state info on all the threads.  */

      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);

        }

      do_cleanups (inner_cleanup);

    }

  while (dirp != NULL);

  do_cleanups (cleanups);

  return;

}

void

procfs_meminfo (char *args, int from_tty)

{

  procfs_mapinfo *mapinfos = NULL;

  static int num_mapinfos = 0;

  procfs_mapinfo *mapinfo_p, *mapinfo_p2;

  int flags = ~0, err, num, i, j;

  struct

  {

    procfs_debuginfo info;

    char buff[_POSIX_PATH_MAX];

  } map;

  struct info

  {

    unsigned addr;

    unsigned size;

    unsigned flags;

    unsigned debug_vaddr;

    unsigned long long offset;

  };

  struct printinfo

  {

    unsigned long long ino;

    unsigned dev;

    struct info text;

    struct info data;

    char name[256];

  } printme;

  /* Get the number of map entrys.  */

  err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);

  if (err != EOK)

    {

      printf ("failed devctl num mapinfos - %d (%s)\n", err,

              safe_strerror (err));

      return;

    }

  mapinfos = xmalloc (num * sizeof (procfs_mapinfo));

  num_mapinfos = num;

  mapinfo_p = mapinfos;

  /* Fill the map entrys.  */

  err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num

                * sizeof (procfs_mapinfo), &num);

  if (err != EOK)

    {

      printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));

      xfree (mapinfos);

      return;

    }

  num = 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.  */

  for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)

    {

      if (!(mapinfo_p->flags & flags))

        mapinfo_p->ino = 0;

      if (mapinfo_p->ino == 0)   /* Already visited.  */

        continue;

      map.info.vaddr = mapinfo_p->vaddr;

      err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);

      if (err != EOK)

        continue;

      memset (&printme, 0, sizeof printme);

      printme.dev = mapinfo_p->dev;

      printme.ino = mapinfo_p->ino;

      printme.text.addr = mapinfo_p->vaddr;

      printme.text.size = mapinfo_p->size;

      printme.text.flags = mapinfo_p->flags;

      printme.text.offset = mapinfo_p->offset;

      printme.text.debug_vaddr = map.info.vaddr;

      strcpy (printme.name, map.info.path);

      /* Check for matching data.  */

      for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)

        {

          if (mapinfo_p2->vaddr != mapinfo_p->vaddr

              && mapinfo_p2->ino == mapinfo_p->ino

              && mapinfo_p2->dev == mapinfo_p->dev)

            {

              map.info.vaddr = mapinfo_p2->vaddr;

              err =

                devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);

              if (err != EOK)

                continue;

              if (strcmp (map.info.path, printme.name))

                continue;

              /* Lower debug_vaddr is always text, if nessessary, swap.  */

              if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)

                {

                  memcpy (&(printme.data), &(printme.text),

                          sizeof (printme.data));

                  printme.text.addr = mapinfo_p2->vaddr;

                  printme.text.size = mapinfo_p2->size;

                  printme.text.flags = mapinfo_p2->flags;

                  printme.text.offset = mapinfo_p2->offset;

                  printme.text.debug_vaddr = map.info.vaddr;

                }

              else

                {

                  printme.data.addr = mapinfo_p2->vaddr;

                  printme.data.size = mapinfo_p2->size;

                  printme.data.flags = mapinfo_p2->flags;

                  printme.data.offset = mapinfo_p2->offset;

                  printme.data.debug_vaddr = map.info.vaddr;

                }

              mapinfo_p2->ino = 0;

            }

        }

      mapinfo_p->ino = 0;

      printf_filtered ("%s\n", printme.name);

      printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,

                       printme.text.addr);

      printf_filtered ("\t\tflags=%08x\n", printme.text.flags);

      printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);

      printf_filtered ("\t\toffset=%016llx\n", printme.text.offset);

      if (printme.data.size)

        {

          printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,

                           printme.data.addr);

          printf_filtered ("\t\tflags=%08x\n", printme.data.flags);

          printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);

          printf_filtered ("\t\toffset=%016llx\n", printme.data.offset);

        }

      printf_filtered ("\tdev=0x%x\n", printme.dev);

      printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);

    }

  xfree (mapinfos);

  return;

}

/* Print status information about what we're accessing.  */

static void

procfs_files_info (struct target_ops *ignore)

{

  struct inferior *inf = current_inferior ();

  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);

}

/* Mark our target-struct as eligible for stray "run" and "attach" commands.  */

static int

procfs_can_run (void)

{

  return 1;

}

/* Attach to process PID, then initialize for debugging it.  */

static void

procfs_attach (struct target_ops *ops, char *args, int from_tty)

{

  char *exec_file;

  int pid;

  struct inferior *inf;

  pid = parse_pid_to_attach (args);

  if (pid == getpid ())

    error (_("Attaching GDB to itself is not a good idea..."));

  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);

    }

  inferior_ptid = do_attach (pid_to_ptid (pid));

  inf = current_inferior ();

  inferior_appeared (inf, pid);

  inf->attach_flag = 1;

  push_target (ops);

  procfs_find_new_threads (ops);

}

static void

procfs_post_attach (pid_t pid)

{

  if (exec_bfd)

    solib_create_inferior_hook (0);

}

static ptid_t

do_attach (ptid_t ptid)

{

  procfs_status status;