gdb/nto-procfs.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* Machine independent support for QNX Neutrino /proc (process file system)
  2.    for GDB.  Written by Colin Burgess at QNX Software Systems Limited.

  4.    Copyright (C) 2003-2015 Free Software Foundation, Inc.

  6.    Contributed by QNX Software Systems Ltd.

  8.    This file is part of GDB.

  10.    This program is free software; you can redistribute it and/or modify
  11.    it under the terms of the GNU General Public License as published by
  12.    the Free Software Foundation; either version 3 of the License, or
  13.    (at your option) any later version.

  15.    This program is distributed in the hope that it will be useful,
  16.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.    GNU General Public License for more details.

  20.    You should have received a copy of the GNU General Public License
  21.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  23. #include "defs.h"

  25. #include <fcntl.h>
  26. #include <spawn.h>
  27. #include <sys/debug.h>
  28. #include <sys/procfs.h>
  29. #include <sys/neutrino.h>
  30. #include <sys/syspage.h>
  31. #include <dirent.h>
  32. #include <sys/netmgr.h>
  33. #include "gdbcore.h"
  34. #include "inferior.h"
  35. #include "target.h"
  36. #include "objfiles.h"
  37. #include "gdbthread.h"
  38. #include "nto-tdep.h"
  39. #include "command.h"
  40. #include "regcache.h"
  41. #include "solib.h"
  42. #include "inf-child.h"

  44. ‌#define NULL_PID                0
  45. ‌#define _DEBUG_FLAG_TRACE        (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
  46.                 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)

  48. ‌int ctl_fd;

  50. ‌static void (*ofunc) ();

  52. ‌static procfs_run run;

  54. static ptid_t do_attach (ptid_t ptid);

  56. static int procfs_can_use_hw_breakpoint (struct target_ops *self,
  57.                                          int, int, int);

  59. static int procfs_insert_hw_watchpoint (struct target_ops *self,
  60.                                         CORE_ADDR addr, int len, int type,
  61.                                         struct expression *cond);

  63. static int procfs_remove_hw_watchpoint (struct target_ops *self,
  64.                                         CORE_ADDR addr, int len, int type,
  65.                                         struct expression *cond);

  67. static int procfs_stopped_by_watchpoint (struct target_ops *ops);

  69. /* These two globals are only ever set in procfs_open_1, but are
  70.    referenced elsewhere.  'nto_procfs_node' is a flag used to say
  71.    whether we are local, or we should get the current node descriptor
  72.    for the remote QNX node.  */
  73. ‌static char nto_procfs_path[PATH_MAX] = { "/proc" };
  74. ‌static unsigned nto_procfs_node = ND_LOCAL_NODE;

  76. /* Return the current QNX Node, or error out.  This is a simple
  77.    wrapper for the netmgr_strtond() function.  The reason this
  78.    is required is because QNX node descriptors are transient so
  79.    we have to re-acquire them every time.  */
  80. static unsigned
  81. ‌nto_node (void)
  82. {
  83.   unsigned node;

  85.   if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0)
  86.     return ND_LOCAL_NODE;

  88.   node = netmgr_strtond (nto_procfs_path, 0);
  89.   if (node == -1)
  90.     error (_("Lost the QNX node.  Debug session probably over."));

  92.   return (node);
  93. }

  95. static enum gdb_osabi
  96. ‌procfs_is_nto_target (bfd *abfd)
  97. {
  98.   return GDB_OSABI_QNXNTO;
  99. }

  101. /* This is called when we call 'target native' or 'target procfs
  102.    <arg>' from the (gdb) prompt.  For QNX6 (nto), the only valid arg
  103.    will be a QNX node string, eg: "/net/some_node".  If arg is not a
  104.    valid QNX node, we will default to local.  */
  105. static void
  106. ‌procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty)
  107. {
  108.   char *nodestr;
  109.   char *endstr;
  110.   char buffer[50];
  111.   int fd, total_size;
  112.   procfs_sysinfo *sysinfo;
  113.   struct cleanup *cleanups;

  115.   /* Offer to kill previous inferiors before opening this target.  */
  116.   target_preopen (from_tty);

  118.   nto_is_nto_target = procfs_is_nto_target;

  120.   /* Set the default node used for spawning to this one,
  121.      and only override it if there is a valid arg.  */

  123.   nto_procfs_node = ND_LOCAL_NODE;
  124.   nodestr = arg ? xstrdup (arg) : arg;

  126.   init_thread_list ();

  128.   if (nodestr)
  129.     {
  130.       nto_procfs_node = netmgr_strtond (nodestr, &endstr);
  131.       if (nto_procfs_node == -1)
  132.         {
  133.           if (errno == ENOTSUP)
  134.             printf_filtered ("QNX Net Manager not found.\n");
  135.           printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr,
  136.                            errno, safe_strerror (errno));
  137.           xfree (nodestr);
  138.           nodestr = NULL;
  139.           nto_procfs_node = ND_LOCAL_NODE;
  140.         }
  141.       else if (*endstr)
  142.         {
  143.           if (*(endstr - 1) == '/')
  144.             *(endstr - 1) = 0;
  145.           else
  146.             *endstr = 0;
  147.         }
  148.     }
  149.   snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "",
  150.             "/proc");
  151.   if (nodestr)
  152.     xfree (nodestr);

  154.   fd = open (nto_procfs_path, O_RDONLY);
  155.   if (fd == -1)
  156.     {
  157.       printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
  158.                        safe_strerror (errno));
  159.       error (_("Invalid procfs arg"));
  160.     }
  161.   cleanups = make_cleanup_close (fd);

  163.   sysinfo = (void *) buffer;
  164.   if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
  165.     {
  166.       printf_filtered ("Error getting size: %d (%s)\n", errno,
  167.                        safe_strerror (errno));
  168.       error (_("Devctl failed."));
  169.     }
  170.   else
  171.     {
  172.       total_size = sysinfo->total_size;
  173.       sysinfo = alloca (total_size);
  174.       if (!sysinfo)
  175.         {
  176.           printf_filtered ("Memory error: %d (%s)\n", errno,
  177.                            safe_strerror (errno));
  178.           error (_("alloca failed."));
  179.         }
  180.       else
  181.         {
  182.           if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
  183.             {
  184.               printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
  185.                                safe_strerror (errno));
  186.               error (_("Devctl failed."));
  187.             }
  188.           else
  189.             {
  190.               if (sysinfo->type !=
  191.                   nto_map_arch_to_cputype (gdbarch_bfd_arch_info
  192.                                            (target_gdbarch ())->arch_name))
  193.                 error (_("Invalid target CPU."));
  194.             }
  195.         }
  196.     }
  197.   do_cleanups (cleanups);

  199.   inf_child_open_target (ops, arg, from_tty);
  200.   printf_filtered ("Debugging using %s\n", nto_procfs_path);
  201. }

  203. static void
  204. ‌procfs_set_thread (ptid_t ptid)
  205. {
  206.   pid_t tid;

  208.   tid = ptid_get_tid (ptid);
  209.   devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
  210. }

  212. /*  Return nonzero if the thread TH is still alive.  */
  213. static int
  214. ‌procfs_thread_alive (struct target_ops *ops, ptid_t ptid)
  215. {
  216.   pid_t tid;
  217.   pid_t pid;
  218.   procfs_status status;
  219.   int err;

  221.   tid = ptid_get_tid (ptid);
  222.   pid = ptid_get_pid (ptid);

  224.   if (kill (pid, 0) == -1)
  225.     return 0;

  227.   status.tid = tid;
  228.   if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS,
  229.                      &status, sizeof (status), 0)) != EOK)
  230.     return 0;

  232.   /* Thread is alive or dead but not yet joined,
  233.      or dead and there is an alive (or dead unjoined) thread with
  234.      higher tid.

  236.      If the tid is not the same as requested, requested tid is dead.  */
  237.   return (status.tid == tid) && (status.state != STATE_DEAD);
  238. }

  240. static void
  241. ‌update_thread_private_data_name (struct thread_info *new_thread,
  242.                                  const char *newname)
  243. {
  244.   int newnamelen;
  245.   struct private_thread_info *pti;

  247.   gdb_assert (newname != NULL);
  248.   gdb_assert (new_thread != NULL);
  249.   newnamelen = strlen (newname);
  250.   if (!new_thread->private)
  251.     {
  252.       new_thread->private = xmalloc (offsetof (struct private_thread_info,
  253.                                                name)
  254.                                      + newnamelen + 1);
  255.       memcpy (new_thread->private->name, newname, newnamelen + 1);
  256.     }
  257.   else if (strcmp (newname, new_thread->private->name) != 0)
  258.     {
  259.       /* Reallocate if neccessary.  */
  260.       int oldnamelen = strlen (new_thread->private->name);

  262.       if (oldnamelen < newnamelen)
  263.         new_thread->private = xrealloc (new_thread->private,
  264.                                         offsetof (struct private_thread_info,
  265.                                                   name)
  266.                                         + newnamelen + 1);
  267.       memcpy (new_thread->private->name, newname, newnamelen + 1);
  268.     }
  269. }

  271. static void
  272. ‌update_thread_private_data (struct thread_info *new_thread,
  273.                             pthread_t tid, int state, int flags)
  274. {
  275.   struct private_thread_info *pti;
  276.   procfs_info pidinfo;
  277.   struct _thread_name *tn;
  278.   procfs_threadctl tctl;

  280. #if _NTO_VERSION > 630
  281.   gdb_assert (new_thread != NULL);

  283.   if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo,
  284.               sizeof(pidinfo), 0) != EOK)
  285.     return;

  287.   memset (&tctl, 0, sizeof (tctl));
  288.   tctl.cmd = _NTO_TCTL_NAME;
  289.   tn = (struct _thread_name *) (&tctl.data);

  291.   /* Fetch name for the given thread.  */
  292.   tctl.tid = tid;
  293.   tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn);
  294.   tn->new_name_len = -1; /* Getting, not setting.  */
  295.   if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK)
  296.     tn->name_buf[0] = '\0';

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

  300.   update_thread_private_data_name (new_thread, tn->name_buf);

  302.   pti = (struct private_thread_info *) new_thread->private;
  303.   pti->tid = tid;
  304.   pti->state = state;
  305.   pti->flags = flags;
  306. #endif /* _NTO_VERSION */
  307. }

  309. static void
  310. ‌procfs_update_thread_list (struct target_ops *ops)
  311. {
  312.   procfs_status status;
  313.   pid_t pid;
  314.   ptid_t ptid;
  315.   pthread_t tid;
  316.   struct thread_info *new_thread;

  318.   if (ctl_fd == -1)
  319.     return;

  321.   prune_threads ();

  323.   pid = ptid_get_pid (inferior_ptid);

  325.   status.tid = 1;

  327.   for (tid = 1;; ++tid)
  328.     {
  329.       if (status.tid == tid
  330.           && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
  331.               != EOK))
  332.         break;
  333.       if (status.tid != tid)
  334.         /* The reason why this would not be equal is that devctl might have
  335.            returned different tid, meaning the requested tid no longer exists
  336.            (e.g. thread exited).  */
  337.         continue;
  338.       ptid = ptid_build (pid, 0, tid);
  339.       new_thread = find_thread_ptid (ptid);
  340.       if (!new_thread)
  341.         new_thread = add_thread (ptid);
  342.       update_thread_private_data (new_thread, tid, status.state, 0);
  343.       status.tid++;
  344.     }
  345.   return;
  346. }

  348. static void
  349. ‌do_closedir_cleanup (void *dir)
  350. {
  351.   closedir (dir);
  352. }

  354. void
  355. ‌procfs_pidlist (char *args, int from_tty)
  356. {
  357.   DIR *dp = NULL;
  358.   struct dirent *dirp = NULL;
  359.   char buf[512];
  360.   procfs_info *pidinfo = NULL;
  361.   procfs_debuginfo *info = NULL;
  362.   procfs_status *status = NULL;
  363.   pid_t num_threads = 0;
  364.   pid_t pid;
  365.   char name[512];
  366.   struct cleanup *cleanups;

  368.   dp = opendir (nto_procfs_path);
  369.   if (dp == NULL)
  370.     {
  371.       fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
  372.                           nto_procfs_path, errno, safe_strerror (errno));
  373.       return;
  374.     }

  376.   cleanups = make_cleanup (do_closedir_cleanup, dp);

  378.   /* Start scan at first pid.  */
  379.   rewinddir (dp);

  381.   do
  382.     {
  383.       int fd;
  384.       struct cleanup *inner_cleanup;

  386.       /* Get the right pid and procfs path for the pid.  */
  387.       do
  388.         {
  389.           dirp = readdir (dp);
  390.           if (dirp == NULL)
  391.             {
  392.               do_cleanups (cleanups);
  393.               return;
  394.             }
  395.           snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name);
  396.           pid = atoi (dirp->d_name);
  397.         }
  398.       while (pid == 0);

  400.       /* Open the procfs path.  */
  401.       fd = open (buf, O_RDONLY);
  402.       if (fd == -1)
  403.         {
  404.           fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
  405.                               buf, errno, safe_strerror (errno));
  406.           do_cleanups (cleanups);
  407.           return;
  408.         }
  409.       inner_cleanup = make_cleanup_close (fd);

  411.       pidinfo = (procfs_info *) buf;
  412.       if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
  413.         {
  414.           fprintf_unfiltered (gdb_stderr,
  415.                               "devctl DCMD_PROC_INFO failed - %d (%s)\n",
  416.                               errno, safe_strerror (errno));
  417.           break;
  418.         }
  419.       num_threads = pidinfo->num_threads;

  421.       info = (procfs_debuginfo *) buf;
  422.       if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)
  423.         strcpy (name, "unavailable");
  424.       else
  425.         strcpy (name, info->path);

  427.       /* Collect state info on all the threads.  */
  428.       status = (procfs_status *) buf;
  429.       for (status->tid = 1; status->tid <= num_threads; status->tid++)
  430.         {
  431.           if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK
  432.               && status->tid != 0)
  433.             break;
  434.           if (status->tid != 0)
  435.             printf_filtered ("%s - %d/%d\n", name, pid, status->tid);
  436.         }

  438.       do_cleanups (inner_cleanup);
  439.     }
  440.   while (dirp != NULL);

  442.   do_cleanups (cleanups);
  443.   return;
  444. }

  446. void
  447. ‌procfs_meminfo (char *args, int from_tty)
  448. {
  449.   procfs_mapinfo *mapinfos = NULL;
  450.   static int num_mapinfos = 0;
  451.   procfs_mapinfo *mapinfo_p, *mapinfo_p2;
  452.   int flags = ~0, err, num, i, j;

  454.   struct
  455.   {
  456.     procfs_debuginfo info;
  457.     char buff[_POSIX_PATH_MAX];
  458.   } map;

  460.   struct info
  461.   {
  462.     unsigned addr;
  463.     unsigned size;
  464.     unsigned flags;
  465.     unsigned debug_vaddr;
  466.     unsigned long long offset;
  467.   };

  469.   struct printinfo
  470.   {
  471.     unsigned long long ino;
  472.     unsigned dev;
  473.     struct info text;
  474.     struct info data;
  475.     char name[256];
  476.   } printme;

  478.   /* Get the number of map entrys.  */
  479.   err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
  480.   if (err != EOK)
  481.     {
  482.       printf ("failed devctl num mapinfos - %d (%s)\n", err,
  483.               safe_strerror (err));
  484.       return;
  485.     }

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

  489.   num_mapinfos = num;
  490.   mapinfo_p = mapinfos;

  492.   /* Fill the map entrys.  */
  493.   err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
  494.                 * sizeof (procfs_mapinfo), &num);
  495.   if (err != EOK)
  496.     {
  497.       printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
  498.       xfree (mapinfos);
  499.       return;
  500.     }

  502.   num = min (num, num_mapinfos);

  504.   /* Run through the list of mapinfos, and store the data and text info
  505.      so we can print it at the bottom of the loop.  */
  506.   for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
  507.     {
  508.       if (!(mapinfo_p->flags & flags))
  509.         mapinfo_p->ino = 0;

  511.       if (mapinfo_p->ino == 0)        /* Already visited.  */
  512.         continue;

  514.       map.info.vaddr = mapinfo_p->vaddr;

  516.       err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
  517.       if (err != EOK)
  518.         continue;

  520.       memset (&printme, 0, sizeof printme);
  521.       printme.dev = mapinfo_p->dev;
  522.       printme.ino = mapinfo_p->ino;
  523.       printme.text.addr = mapinfo_p->vaddr;
  524.       printme.text.size = mapinfo_p->size;
  525.       printme.text.flags = mapinfo_p->flags;
  526.       printme.text.offset = mapinfo_p->offset;
  527.       printme.text.debug_vaddr = map.info.vaddr;
  528.       strcpy (printme.name, map.info.path);

  530.       /* Check for matching data.  */
  531.       for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
  532.         {
  533.           if (mapinfo_p2->vaddr != mapinfo_p->vaddr
  534.               && mapinfo_p2->ino == mapinfo_p->ino
  535.               && mapinfo_p2->dev == mapinfo_p->dev)
  536.             {
  537.               map.info.vaddr = mapinfo_p2->vaddr;
  538.               err =
  539.                 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
  540.               if (err != EOK)
  541.                 continue;

  543.               if (strcmp (map.info.path, printme.name))
  544.                 continue;

  546.               /* Lower debug_vaddr is always text, if nessessary, swap.  */
  547.               if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
  548.                 {
  549.                   memcpy (&(printme.data), &(printme.text),
  550.                           sizeof (printme.data));
  551.                   printme.text.addr = mapinfo_p2->vaddr;
  552.                   printme.text.size = mapinfo_p2->size;
  553.                   printme.text.flags = mapinfo_p2->flags;
  554.                   printme.text.offset = mapinfo_p2->offset;
  555.                   printme.text.debug_vaddr = map.info.vaddr;
  556.                 }
  557.               else
  558.                 {
  559.                   printme.data.addr = mapinfo_p2->vaddr;
  560.                   printme.data.size = mapinfo_p2->size;
  561.                   printme.data.flags = mapinfo_p2->flags;
  562.                   printme.data.offset = mapinfo_p2->offset;
  563.                   printme.data.debug_vaddr = map.info.vaddr;
  564.                 }
  565.               mapinfo_p2->ino = 0;
  566.             }
  567.         }
  568.       mapinfo_p->ino = 0;

  570.       printf_filtered ("%s\n", printme.name);
  571.       printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
  572.                        printme.text.addr);
  573.       printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
  574.       printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
  575.       printf_filtered ("\t\toffset=%s\n", phex (printme.text.offset, 8));
  576.       if (printme.data.size)
  577.         {
  578.           printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
  579.                            printme.data.addr);
  580.           printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
  581.           printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
  582.           printf_filtered ("\t\toffset=%s\n", phex (printme.data.offset, 8));
  583.         }
  584.       printf_filtered ("\tdev=0x%x\n", printme.dev);
  585.       printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
  586.     }
  587.   xfree (mapinfos);
  588.   return;
  589. }

  591. /* Print status information about what we're accessing.  */
  592. static void
  593. ‌procfs_files_info (struct target_ops *ignore)
  594. {
  595.   struct inferior *inf = current_inferior ();

  597.   printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
  598.                      inf->attach_flag ? "attached" : "child",
  599.                      target_pid_to_str (inferior_ptid), nto_procfs_path);
  600. }

  602. /* Attach to process PID, then initialize for debugging it.  */
  603. static void
  604. ‌procfs_attach (struct target_ops *ops, const char *args, int from_tty)
  605. {
  606.   char *exec_file;
  607.   int pid;
  608.   struct inferior *inf;

  610.   pid = parse_pid_to_attach (args);

  612.   if (pid == getpid ())
  613.     error (_("Attaching GDB to itself is not a good idea..."));

  615.   if (from_tty)
  616.     {
  617.       exec_file = (char *) get_exec_file (0);

  619.       if (exec_file)
  620.         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
  621.                            target_pid_to_str (pid_to_ptid (pid)));
  622.       else
  623.         printf_unfiltered ("Attaching to %s\n",
  624.                            target_pid_to_str (pid_to_ptid (pid)));

  626.       gdb_flush (gdb_stdout);
  627.     }
  628.   inferior_ptid = do_attach (pid_to_ptid (pid));
  629.   inf = current_inferior ();
  630.   inferior_appeared (inf, pid);
  631.   inf->attach_flag = 1;

  633.   if (!target_is_pushed (ops))
  634.     push_target (ops);

  636.   procfs_update_thread_list (ops);
  637. }

  639. static void
  640. ‌procfs_post_attach (struct target_ops *self, pid_t pid)
  641. {
  642.   if (exec_bfd)
  643.     solib_create_inferior_hook (0);
  644. }

  646. static ptid_t
  647. ‌do_attach (ptid_t ptid)
  648. {
  649.   procfs_status status;
  650.   struct sigevent event;
  651.   char path[PATH_MAX];

  653.   snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path,
  654.             ptid_get_pid (ptid));
  655.   ctl_fd = open (path, O_RDWR);
  656.   if (ctl_fd == -1)
  657.     error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
  658.            safe_strerror (errno));
  659.   if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
  660.     error (_("Couldn't stop process"));

  662.   /* Define a sigevent for process stopped notification.  */
  663.   event.sigev_notify = SIGEV_SIGNAL_THREAD;
  664.   event.sigev_signo = SIGUSR1;
  665.   event.sigev_code = 0;
  666.   event.sigev_value.sival_ptr = NULL;
  667.   event.sigev_priority = -1;
  668.   devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);

  670.   if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
  671.       && status.flags & _DEBUG_FLAG_STOPPED)
  672.     SignalKill (nto_node (), ptid_get_pid (ptid), 0, SIGCONT, 0, 0);
  673.   nto_init_solib_absolute_prefix ();
  674.   return ptid_build (ptid_get_pid (ptid), 0, status.tid);
  675. }

  677. /* Ask the user what to do when an interrupt is received.  */
  678. static void
  679. ‌interrupt_query (void)
  680. {
  681.   target_terminal_ours ();

  683.   if (query (_("Interrupted while waiting for the program.\n\
  684. Give up (and stop debugging it)? ")))
  685.     {
  686.       target_mourn_inferior ();
  687.       quit ();
  688.     }

  690.   target_terminal_inferior ();
  691. }

  693. /* The user typed ^C twice.  */
  694. static void
  695. ‌nto_interrupt_twice (int signo)
  696. {
  697.   signal (signo, ofunc);
  698.   interrupt_query ();
  699.   signal (signo, nto_interrupt_twice);
  700. }

  702. static void
  703. ‌nto_interrupt (int signo)
  704. {
  705.   /* If this doesn't work, try more severe steps.  */
  706.   signal (signo, nto_interrupt_twice);

  708.   target_stop (inferior_ptid);
  709. }

  711. static ptid_t
  712. ‌procfs_wait (struct target_ops *ops,
  713.              ptid_t ptid, struct target_waitstatus *ourstatus, int options)
  714. {
  715.   sigset_t set;
  716.   siginfo_t info;
  717.   procfs_status status;
  718.   static int exit_signo = 0;        /* To track signals that cause termination.  */

  720.   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;

  722.   if (ptid_equal (inferior_ptid, null_ptid))
  723.     {
  724.       ourstatus->kind = TARGET_WAITKIND_STOPPED;
  725.       ourstatus->value.sig = GDB_SIGNAL_0;
  726.       exit_signo = 0;
  727.       return null_ptid;
  728.     }

  730.   sigemptyset (&set);
  731.   sigaddset (&set, SIGUSR1);

  733.   devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
  734.   while (!(status.flags & _DEBUG_FLAG_ISTOP))
  735.     {
  736.       ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
  737.       sigwaitinfo (&set, &info);
  738.       signal (SIGINT, ofunc);
  739.       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
  740.     }

  742.   if (status.flags & _DEBUG_FLAG_SSTEP)
  743.     {
  744.       ourstatus->kind = TARGET_WAITKIND_STOPPED;
  745.       ourstatus->value.sig = GDB_SIGNAL_TRAP;
  746.     }
  747.   /* Was it a breakpoint?  */
  748.   else if (status.flags & _DEBUG_FLAG_TRACE)
  749.     {
  750.       ourstatus->kind = TARGET_WAITKIND_STOPPED;
  751.       ourstatus->value.sig = GDB_SIGNAL_TRAP;
  752.     }
  753.   else if (status.flags & _DEBUG_FLAG_ISTOP)
  754.     {
  755.       switch (status.why)
  756.         {
  757.         case _DEBUG_WHY_SIGNALLED:
  758.           ourstatus->kind = TARGET_WAITKIND_STOPPED;
  759.           ourstatus->value.sig =
  760.             gdb_signal_from_host (status.info.si_signo);
  761.           exit_signo = 0;
  762.           break;
  763.         case _DEBUG_WHY_FAULTED:
  764.           ourstatus->kind = TARGET_WAITKIND_STOPPED;
  765.           if (status.info.si_signo == SIGTRAP)
  766.             {
  767.               ourstatus->value.sig = 0;
  768.               exit_signo = 0;
  769.             }
  770.           else
  771.             {
  772.               ourstatus->value.sig =
  773.                 gdb_signal_from_host (status.info.si_signo);
  774.               exit_signo = ourstatus->value.sig;
  775.             }
  776.           break;

  778.         case _DEBUG_WHY_TERMINATED:
  779.           {
  780.             int waitval = 0;

  782.             waitpid (ptid_get_pid (inferior_ptid), &waitval, WNOHANG);
  783.             if (exit_signo)
  784.               {
  785.                 /* Abnormal death.  */
  786.                 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
  787.                 ourstatus->value.sig = exit_signo;
  788.               }
  789.             else
  790.               {
  791.                 /* Normal death.  */
  792.                 ourstatus->kind = TARGET_WAITKIND_EXITED;
  793.                 ourstatus->value.integer = WEXITSTATUS (waitval);
  794.               }
  795.             exit_signo = 0;
  796.             break;
  797.           }

  799.         case _DEBUG_WHY_REQUESTED:
  800.           /* We are assuming a requested stop is due to a SIGINT.  */
  801.           ourstatus->kind = TARGET_WAITKIND_STOPPED;
  802.           ourstatus->value.sig = GDB_SIGNAL_INT;
  803.           exit_signo = 0;
  804.           break;
  805.         }
  806.     }

  808.   return ptid_build (status.pid, 0, status.tid);
  809. }

  811. /* Read the current values of the inferior's registers, both the
  812.    general register set and floating point registers (if supported)
  813.    and update gdb's idea of their current values.  */
  814. static void
  815. ‌procfs_fetch_registers (struct target_ops *ops,
  816.                         struct regcache *regcache, int regno)
  817. {
  818.   union
  819.   {
  820.     procfs_greg greg;
  821.     procfs_fpreg fpreg;
  822.     procfs_altreg altreg;
  823.   }
  824.   reg;
  825.   int regsize;

  827.   procfs_set_thread (inferior_ptid);
  828.   if (devctl (ctl_fd, DCMD_PROC_GETGREG, &reg, sizeof (reg), &regsize) == EOK)
  829.     nto_supply_gregset (regcache, (char *) &reg.greg);
  830.   if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
  831.       == EOK)
  832.     nto_supply_fpregset (regcache, (char *) &reg.fpreg);
  833.   if (devctl (ctl_fd, DCMD_PROC_GETALTREG, &reg, sizeof (reg), &regsize)
  834.       == EOK)
  835.     nto_supply_altregset (regcache, (char *) &reg.altreg);
  836. }

  838. /* Helper for procfs_xfer_partial that handles memory transfers.
  839.    Arguments are like target_xfer_partial.  */

  841. static enum target_xfer_status
  842. ‌procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
  843.                     ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
  844. {
  845.   int nbytes;

  847.   if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr)
  848.     return TARGET_XFER_E_IO;

  850.   if (writebuf != NULL)
  851.     nbytes = write (ctl_fd, writebuf, len);
  852.   else
  853.     nbytes = read (ctl_fd, readbuf, len);
  854.   if (nbytes <= 0)
  855.     return TARGET_XFER_E_IO;
  856.   *xfered_len = nbytes;
  857.   return TARGET_XFER_OK;
  858. }

  860. /* Target to_xfer_partial implementation.  */

  862. static enum target_xfer_status
  863. ‌procfs_xfer_partial (struct target_ops *ops, enum target_object object,
  864.                      const char *annex, gdb_byte *readbuf,
  865.                      const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
  866.                      ULONGEST *xfered_len)
  867. {
  868.   switch (object)
  869.     {
  870.     case TARGET_OBJECT_MEMORY:
  871.       return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
  872.     default:
  873.       return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
  874.                                             readbuf, writebuf, offset, len);
  875.     }
  876. }

  878. /* Take a program previously attached to and detaches it.
  879.    The program resumes execution and will no longer stop
  880.    on signals, etc.  We'd better not have left any breakpoints
  881.    in the program or it'll die when it hits one.  */
  882. static void
  883. ‌procfs_detach (struct target_ops *ops, const char *args, int from_tty)
  884. {
  885.   int siggnal = 0;
  886.   int pid;

  888.   if (from_tty)
  889.     {
  890.       char *exec_file = get_exec_file (0);
  891.       if (exec_file == 0)
  892.         exec_file = "";
  893.       printf_unfiltered ("Detaching from program: %s %s\n",
  894.                          exec_file, target_pid_to_str (inferior_ptid));
  895.       gdb_flush (gdb_stdout);
  896.     }
  897.   if (args)
  898.     siggnal = atoi (args);

  900.   if (siggnal)
  901.     SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, siggnal, 0, 0);

  903.   close (ctl_fd);
  904.   ctl_fd = -1;

  906.   pid = ptid_get_pid (inferior_ptid);
  907.   inferior_ptid = null_ptid;
  908.   detach_inferior (pid);
  909.   init_thread_list ();
  910.   inf_child_maybe_unpush_target (ops);
  911. }

  913. static int
  914. ‌procfs_breakpoint (CORE_ADDR addr, int type, int size)
  915. {
  916.   procfs_break brk;

  918.   brk.type = type;
  919.   brk.addr = addr;
  920.   brk.size = size;
  921.   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
  922.   if (errno != EOK)
  923.     return 1;
  924.   return 0;
  925. }

  927. static int
  928. ‌procfs_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
  929.                           struct bp_target_info *bp_tgt)
  930. {
  931.   bp_tgt->placed_address = bp_tgt->reqstd_address;
  932.   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
  933. }

  935. static int
  936. ‌procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
  937.                           struct bp_target_info *bp_tgt)
  938. {
  939.   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
  940. }

  942. static int
  943. ‌procfs_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
  944.                              struct bp_target_info *bp_tgt)
  945. {
  946.   bp_tgt->placed_address = bp_tgt->reqstd_address;
  947.   return procfs_breakpoint (bp_tgt->placed_address,
  948.                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
  949. }

  951. static int
  952. ‌procfs_remove_hw_breakpoint (struct target_ops *self,
  953.                              struct gdbarch *gdbarch,
  954.                              struct bp_target_info *bp_tgt)
  955. {
  956.   return procfs_breakpoint (bp_tgt->placed_address,
  957.                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
  958. }

  960. static void
  961. ‌procfs_resume (struct target_ops *ops,
  962.                ptid_t ptid, int step, enum gdb_signal signo)
  963. {
  964.   int signal_to_pass;
  965.   procfs_status status;
  966.   sigset_t *run_fault = (sigset_t *) (void *) &run.fault;

  968.   if (ptid_equal (inferior_ptid, null_ptid))
  969.     return;

  971.   procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
  972.                      ptid);

  974.   run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
  975.   if (step)
  976.     run.flags |= _DEBUG_RUN_STEP;

  978.   sigemptyset (run_fault);
  979.   sigaddset (run_fault, FLTBPT);
  980.   sigaddset (run_fault, FLTTRACE);
  981.   sigaddset (run_fault, FLTILL);
  982.   sigaddset (run_fault, FLTPRIV);
  983.   sigaddset (run_fault, FLTBOUNDS);
  984.   sigaddset (run_fault, FLTIOVF);
  985.   sigaddset (run_fault, FLTIZDIV);
  986.   sigaddset (run_fault, FLTFPE);
  987.   /* Peter V will be changing this at some point.  */
  988.   sigaddset (run_fault, FLTPAGE);

  990.   run.flags |= _DEBUG_RUN_ARM;

  992.   signal_to_pass = gdb_signal_to_host (signo);

  994.   if (signal_to_pass)
  995.     {
  996.       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
  997.       signal_to_pass = gdb_signal_to_host (signo);
  998.       if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
  999.         {
  1000.           if (signal_to_pass != status.info.si_signo)
  1001.             {
  1002.               SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0,
  1003.                           signal_to_pass, 0, 0);
  1004.               run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
  1005.             }
  1006.           else                /* Let it kill the program without telling us.  */
  1007.             sigdelset (&run.trace, signal_to_pass);
  1008.         }
  1009.     }
  1010.   else
  1011.     run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;

  1013.   errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
  1014.   if (errno != EOK)
  1015.     {
  1016.       perror (_("run error!\n"));
  1017.       return;
  1018.     }
  1019. }

  1021. static void
  1022. ‌procfs_mourn_inferior (struct target_ops *ops)
  1023. {
  1024.   if (!ptid_equal (inferior_ptid, null_ptid))
  1025.     {
  1026.       SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, SIGKILL, 0, 0);
  1027.       close (ctl_fd);
  1028.     }
  1029.   inferior_ptid = null_ptid;
  1030.   init_thread_list ();
  1031.   inf_child_mourn_inferior (ops);
  1032. }

  1034. /* This function breaks up an argument string into an argument
  1035.    vector suitable for passing to execvp().
  1036.    E.g., on "run a b c d" this routine would get as input
  1037.    the string "a b c d", and as output it would fill in argv with
  1038.    the four arguments "a", "b", "c", "d".  The only additional
  1039.    functionality is simple quoting.  The gdb command:
  1040.           run a "b c d" f
  1041.    will fill in argv with the three args "a", "b c d", "e".  */
  1042. static void
  1043. ‌breakup_args (char *scratch, char **argv)
  1044. {
  1045.   char *pp, *cp = scratch;
  1046.   char quoting = 0;

  1048.   for (;;)
  1049.     {
  1050.       /* Scan past leading separators.  */
  1051.       quoting = 0;
  1052.       while (*cp == ' ' || *cp == '\t' || *cp == '\n')
  1053.         cp++;

  1055.       /* Break if at end of string.  */
  1056.       if (*cp == '\0')
  1057.         break;

  1059.       /* Take an arg.  */
  1060.       if (*cp == '"')
  1061.         {
  1062.           cp++;
  1063.           quoting = strchr (cp, '"') ? 1 : 0;
  1064.         }

  1066.       *argv++ = cp;

  1068.       /* Scan for next arg separator.  */
  1069.       pp = cp;
  1070.       if (quoting)
  1071.         cp = strchr (pp, '"');
  1072.       if ((cp == NULL) || (!quoting))
  1073.         cp = strchr (pp, ' ');
  1074.       if (cp == NULL)
  1075.         cp = strchr (pp, '\t');
  1076.       if (cp == NULL)
  1077.         cp = strchr (pp, '\n');

  1079.       /* No separators => end of string => break.  */
  1080.       if (cp == NULL)
  1081.         {
  1082.           pp = cp;
  1083.           break;
  1084.         }

  1086.       /* Replace the separator with a terminator.  */
  1087.       *cp++ = '\0';
  1088.     }

  1090.   /* Execv requires a null-terminated arg vector.  */
  1091.   *argv = NULL;
  1092. }

  1094. static void
  1095. ‌procfs_create_inferior (struct target_ops *ops, char *exec_file,
  1096.                         char *allargs, char **env, int from_tty)
  1097. {
  1098.   struct inheritance inherit;
  1099.   pid_t pid;
  1100.   int flags, errn;
  1101.   char **argv, *args;
  1102.   const char *in = "", *out = "", *err = "";
  1103.   int fd, fds[3];
  1104.   sigset_t set;
  1105.   const char *inferior_io_terminal = get_inferior_io_terminal ();
  1106.   struct inferior *inf;

  1108.   argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
  1109.                   sizeof (*argv));
  1110.   argv[0] = get_exec_file (1);
  1111.   if (!argv[0])
  1112.     {
  1113.       if (exec_file)
  1114.         argv[0] = exec_file;
  1115.       else
  1116.         return;
  1117.     }

  1119.   args = xstrdup (allargs);
  1120.   breakup_args (args, exec_file ? &argv[1] : &argv[0]);

  1122.   argv = nto_parse_redirection (argv, &in, &out, &err);

  1124.   fds[0] = STDIN_FILENO;
  1125.   fds[1] = STDOUT_FILENO;
  1126.   fds[2] = STDERR_FILENO;

  1128.   /* If the user specified I/O via gdb's --tty= arg, use it, but only
  1129.      if the i/o is not also being specified via redirection.  */
  1130.   if (inferior_io_terminal)
  1131.     {
  1132.       if (!in[0])
  1133.         in = inferior_io_terminal;
  1134.       if (!out[0])
  1135.         out = inferior_io_terminal;
  1136.       if (!err[0])
  1137.         err = inferior_io_terminal;
  1138.     }

  1140.   if (in[0])
  1141.     {
  1142.       fd = open (in, O_RDONLY);
  1143.       if (fd == -1)
  1144.         perror (in);
  1145.       else
  1146.         fds[0] = fd;
  1147.     }
  1148.   if (out[0])
  1149.     {
  1150.       fd = open (out, O_WRONLY);
  1151.       if (fd == -1)
  1152.         perror (out);
  1153.       else
  1154.         fds[1] = fd;
  1155.     }
  1156.   if (err[0])
  1157.     {
  1158.       fd = open (err, O_WRONLY);
  1159.       if (fd == -1)
  1160.         perror (err);
  1161.       else
  1162.         fds[2] = fd;
  1163.     }

  1165.   /* Clear any pending SIGUSR1's but keep the behavior the same.  */
  1166.   signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));

  1168.   sigemptyset (&set);
  1169.   sigaddset (&set, SIGUSR1);
  1170.   sigprocmask (SIG_UNBLOCK, &set, NULL);

  1172.   memset (&inherit, 0, sizeof (inherit));

  1174.   if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
  1175.     {
  1176.       inherit.nd = nto_node ();
  1177.       inherit.flags |= SPAWN_SETND;
  1178.       inherit.flags &= ~SPAWN_EXEC;
  1179.     }
  1180.   inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
  1181.   inherit.pgroup = SPAWN_NEWPGROUP;
  1182.   pid = spawnp (argv[0], 3, fds, &inherit, argv,
  1183.                 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
  1184.   xfree (args);

  1186.   sigprocmask (SIG_BLOCK, &set, NULL);

  1188.   if (pid == -1)
  1189.     error (_("Error spawning %s: %d (%s)"), argv[0], errno,
  1190.            safe_strerror (errno));

  1192.   if (fds[0] != STDIN_FILENO)
  1193.     close (fds[0]);
  1194.   if (fds[1] != STDOUT_FILENO)
  1195.     close (fds[1]);
  1196.   if (fds[2] != STDERR_FILENO)
  1197.     close (fds[2]);

  1199.   inferior_ptid = do_attach (pid_to_ptid (pid));
  1200.   procfs_update_thread_list (ops);

  1202.   inf = current_inferior ();
  1203.   inferior_appeared (inf, pid);
  1204.   inf->attach_flag = 0;

  1206.   flags = _DEBUG_FLAG_KLC;        /* Kill-on-Last-Close flag.  */
  1207.   errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
  1208.   if (errn != EOK)
  1209.     {
  1210.       /* FIXME: expected warning?  */
  1211.       /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
  1212.          errn, strerror(errn) ); */
  1213.     }
  1214.   if (!target_is_pushed (ops))
  1215.     push_target (ops);
  1216.   target_terminal_init ();

  1218.   if (exec_bfd != NULL
  1219.       || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
  1220.     solib_create_inferior_hook (0);
  1221. }

  1223. static void
  1224. ‌procfs_stop (struct target_ops *self, ptid_t ptid)
  1225. {
  1226.   devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
  1227. }

  1229. static void
  1230. ‌procfs_kill_inferior (struct target_ops *ops)
  1231. {
  1232.   target_mourn_inferior ();
  1233. }

  1235. /* Fill buf with regset and return devctl cmd to do the setting.  Return
  1236.    -1 if we fail to get the regset.  Store size of regset in regsize.  */
  1237. static int
  1238. ‌get_regset (int regset, char *buf, int bufsize, int *regsize)
  1239. {
  1240.   int dev_get, dev_set;
  1241.   switch (regset)
  1242.     {
  1243.     case NTO_REG_GENERAL:
  1244.       dev_get = DCMD_PROC_GETGREG;
  1245.       dev_set = DCMD_PROC_SETGREG;
  1246.       break;

  1248.     case NTO_REG_FLOAT:
  1249.       dev_get = DCMD_PROC_GETFPREG;
  1250.       dev_set = DCMD_PROC_SETFPREG;
  1251.       break;

  1253.     case NTO_REG_ALT:
  1254.       dev_get = DCMD_PROC_GETALTREG;
  1255.       dev_set = DCMD_PROC_SETALTREG;
  1256.       break;

  1258.     case NTO_REG_SYSTEM:
  1259.     default:
  1260.       return -1;
  1261.     }
  1262.   if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
  1263.     return -1;

  1265.   return dev_set;
  1266. }

  1268. void
  1269. ‌procfs_store_registers (struct target_ops *ops,
  1270.                         struct regcache *regcache, int regno)
  1271. {
  1272.   union
  1273.   {
  1274.     procfs_greg greg;
  1275.     procfs_fpreg fpreg;
  1276.     procfs_altreg altreg;
  1277.   }
  1278.   reg;
  1279.   unsigned off;
  1280.   int len, regset, regsize, dev_set, err;
  1281.   char *data;

  1283.   if (ptid_equal (inferior_ptid, null_ptid))
  1284.     return;
  1285.   procfs_set_thread (inferior_ptid);

  1287.   if (regno == -1)
  1288.     {
  1289.       for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
  1290.         {
  1291.           dev_set = get_regset (regset, (char *) &reg,
  1292.                                 sizeof (reg), &regsize);
  1293.           if (dev_set == -1)
  1294.             continue;

  1296.           if (nto_regset_fill (regcache, regset, (char *) &reg) == -1)
  1297.             continue;

  1299.           err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
  1300.           if (err != EOK)
  1301.             fprintf_unfiltered (gdb_stderr,
  1302.                                 "Warning unable to write regset %d: %s\n",
  1303.                                 regno, safe_strerror (err));
  1304.         }
  1305.     }
  1306.   else
  1307.     {
  1308.       regset = nto_regset_id (regno);
  1309.       if (regset == -1)
  1310.         return;

  1312.       dev_set = get_regset (regset, (char *) &reg, sizeof (reg), &regsize);
  1313.       if (dev_set == -1)
  1314.         return;

  1316.       len = nto_register_area (get_regcache_arch (regcache),
  1317.                                regno, regset, &off);

  1319.       if (len < 1)
  1320.         return;

  1322.       regcache_raw_collect (regcache, regno, (char *) &reg + off);

  1324.       err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
  1325.       if (err != EOK)
  1326.         fprintf_unfiltered (gdb_stderr,
  1327.                             "Warning unable to write regset %d: %s\n", regno,
  1328.                             safe_strerror (err));
  1329.     }
  1330. }

  1332. /* Set list of signals to be handled in the target.  */

  1334. static void
  1335. ‌procfs_pass_signals (struct target_ops *self,
  1336.                      int numsigs, unsigned char *pass_signals)
  1337. {
  1338.   int signo;

  1340.   sigfillset (&run.trace);

  1342.   for (signo = 1; signo < NSIG; signo++)
  1343.     {
  1344.       int target_signo = gdb_signal_from_host (signo);
  1345.       if (target_signo < numsigs && pass_signals[target_signo])
  1346.         sigdelset (&run.trace, signo);
  1347.     }
  1348. }

  1350. static struct tidinfo *
  1351. ‌procfs_thread_info (pid_t pid, short tid)
  1352. {
  1353. /* NYI */
  1354.   return NULL;
  1355. }

  1357. static char *
  1358. ‌procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
  1359. {
  1360.   static char buf[1024];
  1361.   int pid, tid, n;
  1362.   struct tidinfo *tip;

  1364.   pid = ptid_get_pid (ptid);
  1365.   tid = ptid_get_tid (ptid);

  1367.   n = snprintf (buf, 1023, "process %d", pid);

  1369. #if 0                                /* NYI */
  1370.   tip = procfs_thread_info (pid, tid);
  1371.   if (tip != NULL)
  1372.     snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
  1373. #endif

  1375.   return buf;
  1376. }

  1378. /* to_can_run implementation for "target procfs".  Note this really
  1379.   means "can this target be the default run target", which there can
  1380.   be only one, and we make it be "target native" like other ports.
  1381.   "target procfs <node>" wouldn't make sense as default run target, as
  1382.   it needs <node>.  */

  1384. static int
  1385. ‌procfs_can_run (struct target_ops *self)
  1386. {
  1387.   return 0;
  1388. }

  1390. /* "target procfs".  */
  1391. ‌static struct target_ops nto_procfs_ops;

  1393. /* "target native".  */
  1394. ‌static struct target_ops *nto_native_ops;

  1396. /* to_open implementation for "target procfs".  */

  1398. static void
  1399. ‌procfs_open (const char *arg, int from_tty)
  1400. {
  1401.   procfs_open_1 (&nto_procfs_ops, arg, from_tty);
  1402. }

  1404. /* to_open implementation for "target native".  */

  1406. static void
  1407. ‌procfs_native_open (const char *arg, int from_tty)
  1408. {
  1409.   procfs_open_1 (nto_native_ops, arg, from_tty);
  1410. }

  1412. /* Create the "native" and "procfs" targets.  */

  1414. static void
  1415. ‌init_procfs_targets (void)
  1416. {
  1417.   struct target_ops *t = inf_child_target ();

  1419.   /* Leave to_shortname as "native".  */
  1420.   t->to_longname = "QNX Neutrino local process";
  1421.   t->to_doc = "QNX Neutrino local process (started by the \"run\" command).";
  1422.   t->to_open = procfs_native_open;
  1423.   t->to_attach = procfs_attach;
  1424.   t->to_post_attach = procfs_post_attach;
  1425.   t->to_detach = procfs_detach;
  1426.   t->to_resume = procfs_resume;
  1427.   t->to_wait = procfs_wait;
  1428.   t->to_fetch_registers = procfs_fetch_registers;
  1429.   t->to_store_registers = procfs_store_registers;
  1430.   t->to_xfer_partial = procfs_xfer_partial;
  1431.   t->to_files_info = procfs_files_info;
  1432.   t->to_insert_breakpoint = procfs_insert_breakpoint;
  1433.   t->to_remove_breakpoint = procfs_remove_breakpoint;
  1434.   t->to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
  1435.   t->to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
  1436.   t->to_remove_hw_breakpoint = procfs_remove_hw_breakpoint;
  1437.   t->to_insert_watchpoint = procfs_insert_hw_watchpoint;
  1438.   t->to_remove_watchpoint = procfs_remove_hw_watchpoint;
  1439.   t->to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
  1440.   t->to_kill = procfs_kill_inferior;
  1441.   t->to_create_inferior = procfs_create_inferior;
  1442.   t->to_mourn_inferior = procfs_mourn_inferior;
  1443.   t->to_pass_signals = procfs_pass_signals;
  1444.   t->to_thread_alive = procfs_thread_alive;
  1445.   t->to_update_thread_list = procfs_update_thread_list;
  1446.   t->to_pid_to_str = procfs_pid_to_str;
  1447.   t->to_stop = procfs_stop;
  1448.   t->to_have_continuable_watchpoint = 1;
  1449.   t->to_extra_thread_info = nto_extra_thread_info;

  1451.   nto_native_ops = t;

  1453.   /* Register "target native".  This is the default run target.  */
  1454.   add_target (t);

  1456.   /* Register "target procfs <node>".  */
  1457.   nto_procfs_ops = *t;
  1458.   nto_procfs_ops.to_shortname = "procfs";
  1459.   nto_procfs_ops.to_can_run = procfs_can_run;
  1460.   t->to_longname = "QNX Neutrino local or remote process";
  1461.   t->to_doc = "QNX Neutrino process.  target procfs <node>";
  1462.   t->to_open = procfs_open;

  1464.   add_target (&nto_procfs_ops);
  1465. }

  1467. ‌#define OSTYPE_NTO 1

  1469. void
  1470. ‌_initialize_procfs (void)
  1471. {
  1472.   sigset_t set;

  1474.   init_procfs_targets ();

  1476.   /* We use SIGUSR1 to gain control after we block waiting for a process.
  1477.      We use sigwaitevent to wait.  */
  1478.   sigemptyset (&set);
  1479.   sigaddset (&set, SIGUSR1);
  1480.   sigprocmask (SIG_BLOCK, &set, NULL);

  1482.   /* Initially, make sure all signals are reported.  */
  1483.   sigfillset (&run.trace);

  1485.   /* Stuff some information.  */
  1486.   nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
  1487.   nto_cpuinfo_valid = 1;

  1489.   add_info ("pidlist", procfs_pidlist, _("pidlist"));
  1490.   add_info ("meminfo", procfs_meminfo, _("memory information"));

  1492.   nto_is_nto_target = procfs_is_nto_target;
  1493. }


  1496. static int
  1497. ‌procfs_hw_watchpoint (int addr, int len, int type)
  1498. {
  1499.   procfs_break brk;

  1501.   switch (type)
  1502.     {
  1503.     case 1:                        /* Read.  */
  1504.       brk.type = _DEBUG_BREAK_RD;
  1505.       break;
  1506.     case 2:                        /* Read/Write.  */
  1507.       brk.type = _DEBUG_BREAK_RW;
  1508.       break;
  1509.     default:                        /* Modify.  */
  1510. /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason.  */
  1511.       brk.type = _DEBUG_BREAK_RW;
  1512.     }
  1513.   brk.type |= _DEBUG_BREAK_HW;        /* Always ask for HW.  */
  1514.   brk.addr = addr;
  1515.   brk.size = len;

  1517.   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
  1518.   if (errno != EOK)
  1519.     {
  1520.       perror (_("Failed to set hardware watchpoint"));
  1521.       return -1;
  1522.     }
  1523.   return 0;
  1524. }

  1526. static int
  1527. ‌procfs_can_use_hw_breakpoint (struct target_ops *self,
  1528.                               int type, int cnt, int othertype)
  1529. {
  1530.   return 1;
  1531. }

  1533. static int
  1534. ‌procfs_remove_hw_watchpoint (struct target_ops *self,
  1535.                              CORE_ADDR addr, int len, int type,
  1536.                              struct expression *cond)
  1537. {
  1538.   return procfs_hw_watchpoint (addr, -1, type);
  1539. }

  1541. static int
  1542. ‌procfs_insert_hw_watchpoint (struct target_ops *self,
  1543.                              CORE_ADDR addr, int len, int type,
  1544.                              struct expression *cond)
  1545. {
  1546.   return procfs_hw_watchpoint (addr, len, type);
  1547. }

  1549. static int
  1550. ‌procfs_stopped_by_watchpoint (struct target_ops *ops)
  1551. {
  1552.   return 0;
  1553. }