gdb/nto-procfs.c

   1 /* Machine independent support for QNX Neutrino /proc (process file system)
   2    for GDB.  Written by Colin Burgess at QNX Software Systems Limited.
   3
   4    Copyright (C) 2003-2014 Free Software Foundation, Inc.
   5
   6    Contributed by QNX Software Systems Ltd.
   7
   8    This file is part of GDB.
   9
  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.
  14
  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.
  19
  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/>.  */
  22
  23 #include "defs.h"
  24
  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
  34 #include "exceptions.h"
  35 #include <string.h>
  36 #include "gdbcore.h"
  37 #include "inferior.h"
  38 #include "target.h"
  39 #include "objfiles.h"
  40 #include "gdbthread.h"
  41 #include "nto-tdep.h"
  42 #include "command.h"
  43 #include "regcache.h"
  44 #include "solib.h"
  45
  46 #define NULL_PID                0
  47 #define _DEBUG_FLAG_TRACE       (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
  48                 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
  49
  50 static struct target_ops procfs_ops;
  51
  52 int ctl_fd;
  53
  54 static void (*ofunc) ();
  55
  56 static procfs_run run;
  57
  58 static void procfs_open (char *, int);
  59
  60 static int procfs_can_run (void);
  61
  62 static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
  63                                struct mem_attrib *attrib,
  64                                struct target_ops *);
  65
  66 static void init_procfs_ops (void);
  67
  68 static ptid_t do_attach (ptid_t ptid);
  69
  70 static int procfs_can_use_hw_breakpoint (struct target_ops *self,
  71                                          int, int, int);
  72
  73 static int procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type,
  74                                         struct expression *cond);
  75
  76 static int procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type,
  77                                         struct expression *cond);
  78
  79 static int procfs_stopped_by_watchpoint (struct target_ops *ops);
  80
  81 /* These two globals are only ever set in procfs_open(), but are
  82    referenced elsewhere.  'nto_procfs_node' is a flag used to say
  83    whether we are local, or we should get the current node descriptor
  84    for the remote QNX node.  */
  85 static char nto_procfs_path[PATH_MAX] = { "/proc" };
  86 static unsigned nto_procfs_node = ND_LOCAL_NODE;
  87
  88 /* Return the current QNX Node, or error out.  This is a simple
  89    wrapper for the netmgr_strtond() function.  The reason this
  90    is required is because QNX node descriptors are transient so
  91    we have to re-acquire them every time.  */
  92 static unsigned
  93 nto_node (void)
  94 {
  95   unsigned node;
  96
  97   if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0)
  98     return ND_LOCAL_NODE;
  99
 100   node = netmgr_strtond (nto_procfs_path, 0);
 101   if (node == -1)
 102     error (_("Lost the QNX node.  Debug session probably over."));
 103
 104   return (node);
 105 }
 106
 107 static enum gdb_osabi
 108 procfs_is_nto_target (bfd *abfd)
 109 {
 110   return GDB_OSABI_QNXNTO;
 111 }
 112
 113 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
 114    For QNX6 (nto), the only valid arg will be a QNX node string,
 115    eg: "/net/some_node".  If arg is not a valid QNX node, we will
 116    default to local.  */
 117 static void
 118 procfs_open (char *arg, int from_tty)
 119 {
 120   char *nodestr;
 121   char *endstr;
 122   char buffer[50];
 123   int fd, total_size;
 124   procfs_sysinfo *sysinfo;
 125   struct cleanup *cleanups;
 126
 127   nto_is_nto_target = procfs_is_nto_target;
 128
 129   /* Set the default node used for spawning to this one,
 130      and only override it if there is a valid arg.  */
 131
 132   nto_procfs_node = ND_LOCAL_NODE;
 133   nodestr = arg ? xstrdup (arg) : arg;
 134
 135   init_thread_list ();
 136
 137   if (nodestr)
 138     {
 139       nto_procfs_node = netmgr_strtond (nodestr, &endstr);
 140       if (nto_procfs_node == -1)
 141         {
 142           if (errno == ENOTSUP)
 143             printf_filtered ("QNX Net Manager not found.\n");
 144           printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr,
 145                            errno, safe_strerror (errno));
 146           xfree (nodestr);
 147           nodestr = NULL;
 148           nto_procfs_node = ND_LOCAL_NODE;
 149         }
 150       else if (*endstr)
 151         {
 152           if (*(endstr - 1) == '/')
 153             *(endstr - 1) = 0;
 154           else
 155             *endstr = 0;
 156         }
 157     }
 158   snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "",
 159             "/proc");
 160   if (nodestr)
 161     xfree (nodestr);
 162
 163   fd = open (nto_procfs_path, O_RDONLY);
 164   if (fd == -1)
 165     {
 166       printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
 167                        safe_strerror (errno));
 168       error (_("Invalid procfs arg"));
 169     }
 170   cleanups = make_cleanup_close (fd);
 171
 172   sysinfo = (void *) buffer;
 173   if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
 174     {
 175       printf_filtered ("Error getting size: %d (%s)\n", errno,
 176                        safe_strerror (errno));
 177       error (_("Devctl failed."));
 178     }
 179   else
 180     {
 181       total_size = sysinfo->total_size;
 182       sysinfo = alloca (total_size);
 183       if (!sysinfo)
 184         {
 185           printf_filtered ("Memory error: %d (%s)\n", errno,
 186                            safe_strerror (errno));
 187           error (_("alloca failed."));
 188         }
 189       else
 190         {
 191           if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
 192             {
 193               printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
 194                                safe_strerror (errno));
 195               error (_("Devctl failed."));
 196             }
 197           else
 198             {
 199               if (sysinfo->type !=
 200                   nto_map_arch_to_cputype (gdbarch_bfd_arch_info
 201                                            (target_gdbarch ())->arch_name))
 202                 error (_("Invalid target CPU."));
 203             }
 204         }
 205     }
 206   do_cleanups (cleanups);
 207   printf_filtered ("Debugging using %s\n", nto_procfs_path);
 208 }
 209
 210 static void
 211 procfs_set_thread (ptid_t ptid)
 212 {
 213   pid_t tid;
 214
 215   tid = ptid_get_tid (ptid);
 216   devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
 217 }
 218
 219 /*  Return nonzero if the thread TH is still alive.  */
 220 static int
 221 procfs_thread_alive (struct target_ops *ops, ptid_t ptid)
 222 {
 223   pid_t tid;
 224   pid_t pid;
 225   procfs_status status;
 226   int err;
 227
 228   tid = ptid_get_tid (ptid);
 229   pid = ptid_get_pid (ptid);
 230
 231   if (kill (pid, 0) == -1)
 232     return 0;
 233
 234   status.tid = tid;
 235   if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS,
 236                      &status, sizeof (status), 0)) != EOK)
 237     return 0;
 238
 239   /* Thread is alive or dead but not yet joined,
 240      or dead and there is an alive (or dead unjoined) thread with
 241      higher tid.
 242
 243      If the tid is not the same as requested, requested tid is dead.  */
 244   return (status.tid == tid) && (status.state != STATE_DEAD);
 245 }
 246
 247 static void
 248 update_thread_private_data_name (struct thread_info *new_thread,
 249                                  const char *newname)
 250 {
 251   int newnamelen;
 252   struct private_thread_info *pti;
 253
 254   gdb_assert (newname != NULL);
 255   gdb_assert (new_thread != NULL);
 256   newnamelen = strlen (newname);
 257   if (!new_thread->private)
 258     {
 259       new_thread->private = xmalloc (offsetof (struct private_thread_info,
 260                                                name)
 261                                      + newnamelen + 1);
 262       memcpy (new_thread->private->name, newname, newnamelen + 1);
 263     }
 264   else if (strcmp (newname, new_thread->private->name) != 0)
 265     {
 266       /* Reallocate if neccessary.  */
 267       int oldnamelen = strlen (new_thread->private->name);
 268
 269       if (oldnamelen < newnamelen)
 270         new_thread->private = xrealloc (new_thread->private,
 271                                         offsetof (struct private_thread_info,
 272                                                   name)
 273                                         + newnamelen + 1);
 274       memcpy (new_thread->private->name, newname, newnamelen + 1);
 275     }
 276 }
 277
 278 static void
 279 update_thread_private_data (struct thread_info *new_thread,
 280                             pthread_t tid, int state, int flags)
 281 {
 282   struct private_thread_info *pti;
 283   procfs_info pidinfo;
 284   struct _thread_name *tn;
 285   procfs_threadctl tctl;
 286
 287 #if _NTO_VERSION > 630
 288   gdb_assert (new_thread != NULL);
 289
 290   if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo,
 291               sizeof(pidinfo), 0) != EOK)
 292     return;
 293
 294   memset (&tctl, 0, sizeof (tctl));
 295   tctl.cmd = _NTO_TCTL_NAME;
 296   tn = (struct _thread_name *) (&tctl.data);
 297
 298   /* Fetch name for the given thread.  */
 299   tctl.tid = tid;
 300   tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn);
 301   tn->new_name_len = -1; /* Getting, not setting.  */
 302   if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK)
 303     tn->name_buf[0] = '\0';
 304
 305   tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0';
 306
 307   update_thread_private_data_name (new_thread, tn->name_buf);
 308
 309   pti = (struct private_thread_info *) new_thread->private;
 310   pti->tid = tid;
 311   pti->state = state;
 312   pti->flags = flags;
 313 #endif /* _NTO_VERSION */
 314 }
 315
 316 static void
 317 procfs_find_new_threads (struct target_ops *ops)
 318 {
 319   procfs_status status;
 320   pid_t pid;
 321   ptid_t ptid;
 322   pthread_t tid;
 323   struct thread_info *new_thread;
 324
 325   if (ctl_fd == -1)
 326     return;
 327
 328   pid = ptid_get_pid (inferior_ptid);
 329
 330   status.tid = 1;
 331
 332   for (tid = 1;; ++tid)
 333     {
 334       if (status.tid == tid
 335           && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
 336               != EOK))
 337         break;
 338       if (status.tid != tid)
 339         /* The reason why this would not be equal is that devctl might have
 340            returned different tid, meaning the requested tid no longer exists
 341            (e.g. thread exited).  */
 342         continue;
 343       ptid = ptid_build (pid, 0, tid);
 344       new_thread = find_thread_ptid (ptid);
 345       if (!new_thread)
 346         new_thread = add_thread (ptid);
 347       update_thread_private_data (new_thread, tid, status.state, 0);
 348       status.tid++;
 349     }
 350   return;
 351 }
 352
 353 static void
 354 do_closedir_cleanup (void *dir)
 355 {
 356   closedir (dir);
 357 }
 358
 359 void
 360 procfs_pidlist (char *args, int from_tty)
 361 {
 362   DIR *dp = NULL;
 363   struct dirent *dirp = NULL;
 364   char buf[512];
 365   procfs_info *pidinfo = NULL;
 366   procfs_debuginfo *info = NULL;
 367   procfs_status *status = NULL;
 368   pid_t num_threads = 0;
 369   pid_t pid;
 370   char name[512];
 371   struct cleanup *cleanups;
 372
 373   dp = opendir (nto_procfs_path);
 374   if (dp == NULL)
 375     {
 376       fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
 377                           nto_procfs_path, errno, safe_strerror (errno));
 378       return;
 379     }
 380
 381   cleanups = make_cleanup (do_closedir_cleanup, dp);
 382
 383   /* Start scan at first pid.  */
 384   rewinddir (dp);
 385
 386   do
 387     {
 388       int fd;
 389       struct cleanup *inner_cleanup;
 390
 391       /* Get the right pid and procfs path for the pid.  */
 392       do
 393         {
 394           dirp = readdir (dp);
 395           if (dirp == NULL)
 396             {
 397               do_cleanups (cleanups);
 398               return;
 399             }
 400           snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name);
 401           pid = atoi (dirp->d_name);
 402         }
 403       while (pid == 0);
 404
 405       /* Open the procfs path.  */
 406       fd = open (buf, O_RDONLY);
 407       if (fd == -1)
 408         {
 409           fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
 410                               buf, errno, safe_strerror (errno));
 411           do_cleanups (cleanups);
 412           return;
 413         }
 414       inner_cleanup = make_cleanup_close (fd);
 415
 416       pidinfo = (procfs_info *) buf;
 417       if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
 418         {
 419           fprintf_unfiltered (gdb_stderr,
 420                               "devctl DCMD_PROC_INFO failed - %d (%s)\n",
 421                               errno, safe_strerror (errno));
 422           break;
 423         }
 424       num_threads = pidinfo->num_threads;
 425
 426       info = (procfs_debuginfo *) buf;
 427       if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)
 428         strcpy (name, "unavailable");
 429       else
 430         strcpy (name, info->path);
 431
 432       /* Collect state info on all the threads.  */
 433       status = (procfs_status *) buf;
 434       for (status->tid = 1; status->tid <= num_threads; status->tid++)
 435         {
 436           if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK
 437               && status->tid != 0)
 438             break;
 439           if (status->tid != 0)
 440             printf_filtered ("%s - %d/%d\n", name, pid, status->tid);
 441         }
 442
 443       do_cleanups (inner_cleanup);
 444     }
 445   while (dirp != NULL);
 446
 447   do_cleanups (cleanups);
 448   return;
 449 }
 450
 451 void
 452 procfs_meminfo (char *args, int from_tty)
 453 {
 454   procfs_mapinfo *mapinfos = NULL;
 455   static int num_mapinfos = 0;
 456   procfs_mapinfo *mapinfo_p, *mapinfo_p2;
 457   int flags = ~0, err, num, i, j;
 458
 459   struct
 460   {
 461     procfs_debuginfo info;
 462     char buff[_POSIX_PATH_MAX];
 463   } map;
 464
 465   struct info
 466   {
 467     unsigned addr;
 468     unsigned size;
 469     unsigned flags;
 470     unsigned debug_vaddr;
 471     unsigned long long offset;
 472   };
 473
 474   struct printinfo
 475   {
 476     unsigned long long ino;
 477     unsigned dev;
 478     struct info text;
 479     struct info data;
 480     char name[256];
 481   } printme;
 482
 483   /* Get the number of map entrys.  */
 484   err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
 485   if (err != EOK)
 486     {
 487       printf ("failed devctl num mapinfos - %d (%s)\n", err,
 488               safe_strerror (err));
 489       return;
 490     }
 491
 492   mapinfos = xmalloc (num * sizeof (procfs_mapinfo));
 493
 494   num_mapinfos = num;
 495   mapinfo_p = mapinfos;
 496
 497   /* Fill the map entrys.  */
 498   err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
 499                 * sizeof (procfs_mapinfo), &num);
 500   if (err != EOK)
 501     {
 502       printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
 503       xfree (mapinfos);
 504       return;
 505     }
 506
 507   num = min (num, num_mapinfos);
 508
 509   /* Run through the list of mapinfos, and store the data and text info
 510      so we can print it at the bottom of the loop.  */
 511   for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
 512     {
 513       if (!(mapinfo_p->flags & flags))
 514         mapinfo_p->ino = 0;
 515
 516       if (mapinfo_p->ino == 0)  /* Already visited.  */
 517         continue;
 518
 519       map.info.vaddr = mapinfo_p->vaddr;
 520
 521       err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
 522       if (err != EOK)
 523         continue;
 524
 525       memset (&printme, 0, sizeof printme);
 526       printme.dev = mapinfo_p->dev;
 527       printme.ino = mapinfo_p->ino;
 528       printme.text.addr = mapinfo_p->vaddr;
 529       printme.text.size = mapinfo_p->size;
 530       printme.text.flags = mapinfo_p->flags;
 531       printme.text.offset = mapinfo_p->offset;
 532       printme.text.debug_vaddr = map.info.vaddr;
 533       strcpy (printme.name, map.info.path);
 534
 535       /* Check for matching data.  */
 536       for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
 537         {
 538           if (mapinfo_p2->vaddr != mapinfo_p->vaddr
 539               && mapinfo_p2->ino == mapinfo_p->ino
 540               && mapinfo_p2->dev == mapinfo_p->dev)
 541             {
 542               map.info.vaddr = mapinfo_p2->vaddr;
 543               err =
 544                 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
 545               if (err != EOK)
 546                 continue;
 547
 548               if (strcmp (map.info.path, printme.name))
 549                 continue;
 550
 551               /* Lower debug_vaddr is always text, if nessessary, swap.  */
 552               if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
 553                 {
 554                   memcpy (&(printme.data), &(printme.text),
 555                           sizeof (printme.data));
 556                   printme.text.addr = mapinfo_p2->vaddr;
 557                   printme.text.size = mapinfo_p2->size;
 558                   printme.text.flags = mapinfo_p2->flags;
 559                   printme.text.offset = mapinfo_p2->offset;
 560                   printme.text.debug_vaddr = map.info.vaddr;
 561                 }
 562               else
 563                 {
 564                   printme.data.addr = mapinfo_p2->vaddr;
 565                   printme.data.size = mapinfo_p2->size;
 566                   printme.data.flags = mapinfo_p2->flags;
 567                   printme.data.offset = mapinfo_p2->offset;
 568                   printme.data.debug_vaddr = map.info.vaddr;
 569                 }
 570               mapinfo_p2->ino = 0;
 571             }
 572         }
 573       mapinfo_p->ino = 0;
 574
 575       printf_filtered ("%s\n", printme.name);
 576       printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
 577                        printme.text.addr);
 578       printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
 579       printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
 580       printf_filtered ("\t\toffset=%s\n", phex (printme.text.offset, 8));
 581       if (printme.data.size)
 582         {
 583           printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
 584                            printme.data.addr);
 585           printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
 586           printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
 587           printf_filtered ("\t\toffset=%s\n", phex (printme.data.offset, 8));
 588         }
 589       printf_filtered ("\tdev=0x%x\n", printme.dev);
 590       printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
 591     }
 592   xfree (mapinfos);
 593   return;
 594 }
 595
 596 /* Print status information about what we're accessing.  */
 597 static void
 598 procfs_files_info (struct target_ops *ignore)
 599 {
 600   struct inferior *inf = current_inferior ();
 601
 602   printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
 603                      inf->attach_flag ? "attached" : "child",
 604                      target_pid_to_str (inferior_ptid), nto_procfs_path);
 605 }
 606
 607 /* Mark our target-struct as eligible for stray "run" and "attach"
 608    commands.  */
 609 static int
 610 procfs_can_run (void)
 611 {
 612   return 1;
 613 }
 614
 615 /* Attach to process PID, then initialize for debugging it.  */
 616 static void
 617 procfs_attach (struct target_ops *ops, char *args, int from_tty)
 618 {
 619   char *exec_file;
 620   int pid;
 621   struct inferior *inf;
 622
 623   pid = parse_pid_to_attach (args);
 624
 625   if (pid == getpid ())
 626     error (_("Attaching GDB to itself is not a good idea..."));
 627
 628   if (from_tty)
 629     {
 630       exec_file = (char *) get_exec_file (0);
 631
 632       if (exec_file)
 633         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
 634                            target_pid_to_str (pid_to_ptid (pid)));
 635       else
 636         printf_unfiltered ("Attaching to %s\n",
 637                            target_pid_to_str (pid_to_ptid (pid)));
 638
 639       gdb_flush (gdb_stdout);
 640     }
 641   inferior_ptid = do_attach (pid_to_ptid (pid));
 642   inf = current_inferior ();
 643   inferior_appeared (inf, pid);
 644   inf->attach_flag = 1;
 645
 646   push_target (ops);
 647
 648   procfs_find_new_threads (ops);
 649 }
 650
 651 static void
 652 procfs_post_attach (struct target_ops *self, pid_t pid)
 653 {
 654   if (exec_bfd)
 655     solib_create_inferior_hook (0);
 656 }
 657
 658 static ptid_t
 659 do_attach (ptid_t ptid)
 660 {
 661   procfs_status status;
 662   struct sigevent event;
 663   char path[PATH_MAX];
 664
 665   snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path,
 666             ptid_get_pid (ptid));
 667   ctl_fd = open (path, O_RDWR);
 668   if (ctl_fd == -1)
 669     error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
 670            safe_strerror (errno));
 671   if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
 672     error (_("Couldn't stop process"));
 673
 674   /* Define a sigevent for process stopped notification.  */
 675   event.sigev_notify = SIGEV_SIGNAL_THREAD;
 676   event.sigev_signo = SIGUSR1;
 677   event.sigev_code = 0;
 678   event.sigev_value.sival_ptr = NULL;
 679   event.sigev_priority = -1;
 680   devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
 681
 682   if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
 683       && status.flags & _DEBUG_FLAG_STOPPED)
 684     SignalKill (nto_node (), ptid_get_pid (ptid), 0, SIGCONT, 0, 0);
 685   nto_init_solib_absolute_prefix ();
 686   return ptid_build (ptid_get_pid (ptid), 0, status.tid);
 687 }
 688
 689 /* Ask the user what to do when an interrupt is received.  */
 690 static void
 691 interrupt_query (void)
 692 {
 693   target_terminal_ours ();
 694
 695   if (query (_("Interrupted while waiting for the program.\n\
 696 Give up (and stop debugging it)? ")))
 697     {
 698       target_mourn_inferior ();
 699       quit ();
 700     }
 701
 702   target_terminal_inferior ();
 703 }
 704
 705 /* The user typed ^C twice.  */
 706 static void
 707 nto_interrupt_twice (int signo)
 708 {
 709   signal (signo, ofunc);
 710   interrupt_query ();
 711   signal (signo, nto_interrupt_twice);
 712 }
 713
 714 static void
 715 nto_interrupt (int signo)
 716 {
 717   /* If this doesn't work, try more severe steps.  */
 718   signal (signo, nto_interrupt_twice);
 719
 720   target_stop (inferior_ptid);
 721 }
 722
 723 static ptid_t
 724 procfs_wait (struct target_ops *ops,
 725              ptid_t ptid, struct target_waitstatus *ourstatus, int options)
 726 {
 727   sigset_t set;
 728   siginfo_t info;
 729   procfs_status status;
 730   static int exit_signo = 0;    /* To track signals that cause termination.  */
 731
 732   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 733
 734   if (ptid_equal (inferior_ptid, null_ptid))
 735     {
 736       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 737       ourstatus->value.sig = GDB_SIGNAL_0;
 738       exit_signo = 0;
 739       return null_ptid;
 740     }
 741
 742   sigemptyset (&set);
 743   sigaddset (&set, SIGUSR1);
 744
 745   devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 746   while (!(status.flags & _DEBUG_FLAG_ISTOP))
 747     {
 748       ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
 749       sigwaitinfo (&set, &info);
 750       signal (SIGINT, ofunc);
 751       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 752     }
 753
 754   if (status.flags & _DEBUG_FLAG_SSTEP)
 755     {
 756       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 757       ourstatus->value.sig = GDB_SIGNAL_TRAP;
 758     }
 759   /* Was it a breakpoint?  */
 760   else if (status.flags & _DEBUG_FLAG_TRACE)
 761     {
 762       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 763       ourstatus->value.sig = GDB_SIGNAL_TRAP;
 764     }
 765   else if (status.flags & _DEBUG_FLAG_ISTOP)
 766     {
 767       switch (status.why)
 768         {
 769         case _DEBUG_WHY_SIGNALLED:
 770           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 771           ourstatus->value.sig =
 772             gdb_signal_from_host (status.info.si_signo);
 773           exit_signo = 0;
 774           break;
 775         case _DEBUG_WHY_FAULTED:
 776           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 777           if (status.info.si_signo == SIGTRAP)
 778             {
 779               ourstatus->value.sig = 0;
 780               exit_signo = 0;
 781             }
 782           else
 783             {
 784               ourstatus->value.sig =
 785                 gdb_signal_from_host (status.info.si_signo);
 786               exit_signo = ourstatus->value.sig;
 787             }
 788           break;
 789
 790         case _DEBUG_WHY_TERMINATED:
 791           {
 792             int waitval = 0;
 793
 794             waitpid (ptid_get_pid (inferior_ptid), &waitval, WNOHANG);
 795             if (exit_signo)
 796               {
 797                 /* Abnormal death.  */
 798                 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 799                 ourstatus->value.sig = exit_signo;
 800               }
 801             else
 802               {
 803                 /* Normal death.  */
 804                 ourstatus->kind = TARGET_WAITKIND_EXITED;
 805                 ourstatus->value.integer = WEXITSTATUS (waitval);
 806               }
 807             exit_signo = 0;
 808             break;
 809           }
 810
 811         case _DEBUG_WHY_REQUESTED:
 812           /* We are assuming a requested stop is due to a SIGINT.  */
 813           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 814           ourstatus->value.sig = GDB_SIGNAL_INT;
 815           exit_signo = 0;
 816           break;
 817         }
 818     }
 819
 820   return ptid_build (status.pid, 0, status.tid);
 821 }
 822
 823 /* Read the current values of the inferior's registers, both the
 824    general register set and floating point registers (if supported)
 825    and update gdb's idea of their current values.  */
 826 static void
 827 procfs_fetch_registers (struct target_ops *ops,
 828                         struct regcache *regcache, int regno)
 829 {
 830   union
 831   {
 832     procfs_greg greg;
 833     procfs_fpreg fpreg;
 834     procfs_altreg altreg;
 835   }
 836   reg;
 837   int regsize;
 838
 839   procfs_set_thread (inferior_ptid);
 840   if (devctl (ctl_fd, DCMD_PROC_GETGREG, &reg, sizeof (reg), &regsize) == EOK)
 841     nto_supply_gregset (regcache, (char *) &reg.greg);
 842   if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
 843       == EOK)
 844     nto_supply_fpregset (regcache, (char *) &reg.fpreg);
 845   if (devctl (ctl_fd, DCMD_PROC_GETALTREG, &reg, sizeof (reg), &regsize)
 846       == EOK)
 847     nto_supply_altregset (regcache, (char *) &reg.altreg);
 848 }
 849
 850 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
 851    from/to debugger memory starting at MYADDR.  Copy from inferior
 852    if DOWRITE is zero or to inferior if DOWRITE is nonzero.
 853
 854    Returns the length copied, which is either the LEN argument or
 855    zero.  This xfer function does not do partial moves, since procfs_ops
 856    doesn't allow memory operations to cross below us in the target stack
 857    anyway.  */
 858 static int
 859 procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
 860                     struct mem_attrib *attrib, struct target_ops *target)
 861 {
 862   int nbytes = 0;
 863
 864   if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
 865     {
 866       if (dowrite)
 867         nbytes = write (ctl_fd, myaddr, len);
 868       else
 869         nbytes = read (ctl_fd, myaddr, len);
 870       if (nbytes < 0)
 871         nbytes = 0;
 872     }
 873   return (nbytes);
 874 }
 875
 876 /* Take a program previously attached to and detaches it.
 877    The program resumes execution and will no longer stop
 878    on signals, etc.  We'd better not have left any breakpoints
 879    in the program or it'll die when it hits one.  */
 880 static void
 881 procfs_detach (struct target_ops *ops, const char *args, int from_tty)
 882 {
 883   int siggnal = 0;
 884   int pid;
 885
 886   if (from_tty)
 887     {
 888       char *exec_file = get_exec_file (0);
 889       if (exec_file == 0)
 890         exec_file = "";
 891       printf_unfiltered ("Detaching from program: %s %s\n",
 892                          exec_file, target_pid_to_str (inferior_ptid));
 893       gdb_flush (gdb_stdout);
 894     }
 895   if (args)
 896     siggnal = atoi (args);
 897
 898   if (siggnal)
 899     SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, siggnal, 0, 0);
 900
 901   close (ctl_fd);
 902   ctl_fd = -1;
 903
 904   pid = ptid_get_pid (inferior_ptid);
 905   inferior_ptid = null_ptid;
 906   detach_inferior (pid);
 907   init_thread_list ();
 908   unpush_target (&procfs_ops);  /* Pop out of handling an inferior.  */
 909 }
 910
 911 static int
 912 procfs_breakpoint (CORE_ADDR addr, int type, int size)
 913 {
 914   procfs_break brk;
 915
 916   brk.type = type;
 917   brk.addr = addr;
 918   brk.size = size;
 919   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
 920   if (errno != EOK)
 921     return 1;
 922   return 0;
 923 }
 924
 925 static int
 926 procfs_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
 927                           struct bp_target_info *bp_tgt)
 928 {
 929   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
 930 }
 931
 932 static int
 933 procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
 934                           struct bp_target_info *bp_tgt)
 935 {
 936   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
 937 }
 938
 939 static int
 940 procfs_insert_hw_breakpoint (struct gdbarch *gdbarch,
 941                              struct bp_target_info *bp_tgt)
 942 {
 943   return procfs_breakpoint (bp_tgt->placed_address,
 944                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
 945 }
 946
 947 static int
 948 procfs_remove_hw_breakpoint (struct gdbarch *gdbarch,
 949                              struct bp_target_info *bp_tgt)
 950 {
 951   return procfs_breakpoint (bp_tgt->placed_address,
 952                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
 953 }
 954
 955 static void
 956 procfs_resume (struct target_ops *ops,
 957                ptid_t ptid, int step, enum gdb_signal signo)
 958 {
 959   int signal_to_pass;
 960   procfs_status status;
 961   sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
 962
 963   if (ptid_equal (inferior_ptid, null_ptid))
 964     return;
 965
 966   procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
 967                      ptid);
 968
 969   run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
 970   if (step)
 971     run.flags |= _DEBUG_RUN_STEP;
 972
 973   sigemptyset (run_fault);
 974   sigaddset (run_fault, FLTBPT);
 975   sigaddset (run_fault, FLTTRACE);
 976   sigaddset (run_fault, FLTILL);
 977   sigaddset (run_fault, FLTPRIV);
 978   sigaddset (run_fault, FLTBOUNDS);
 979   sigaddset (run_fault, FLTIOVF);
 980   sigaddset (run_fault, FLTIZDIV);
 981   sigaddset (run_fault, FLTFPE);
 982   /* Peter V will be changing this at some point.  */
 983   sigaddset (run_fault, FLTPAGE);
 984
 985   run.flags |= _DEBUG_RUN_ARM;
 986
 987   signal_to_pass = gdb_signal_to_host (signo);
 988
 989   if (signal_to_pass)
 990     {
 991       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 992       signal_to_pass = gdb_signal_to_host (signo);
 993       if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
 994         {
 995           if (signal_to_pass != status.info.si_signo)
 996             {
 997               SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0,
 998                           signal_to_pass, 0, 0);
 999               run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1000             }
1001           else          /* Let it kill the program without telling us.  */
1002             sigdelset (&run.trace, signal_to_pass);
1003         }
1004     }
1005   else
1006     run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1007
1008   errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1009   if (errno != EOK)
1010     {
1011       perror (_("run error!\n"));
1012       return;
1013     }
1014 }
1015
1016 static void
1017 procfs_mourn_inferior (struct target_ops *ops)
1018 {
1019   if (!ptid_equal (inferior_ptid, null_ptid))
1020     {
1021       SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, SIGKILL, 0, 0);
1022       close (ctl_fd);
1023     }
1024   inferior_ptid = null_ptid;
1025   init_thread_list ();
1026   unpush_target (&procfs_ops);
1027   generic_mourn_inferior ();
1028 }
1029
1030 /* This function breaks up an argument string into an argument
1031    vector suitable for passing to execvp().
1032    E.g., on "run a b c d" this routine would get as input
1033    the string "a b c d", and as output it would fill in argv with
1034    the four arguments "a", "b", "c", "d".  The only additional
1035    functionality is simple quoting.  The gdb command:
1036         run a "b c d" f
1037    will fill in argv with the three args "a", "b c d", "e".  */
1038 static void
1039 breakup_args (char *scratch, char **argv)
1040 {
1041   char *pp, *cp = scratch;
1042   char quoting = 0;
1043
1044   for (;;)
1045     {
1046       /* Scan past leading separators.  */
1047       quoting = 0;
1048       while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1049         cp++;
1050
1051       /* Break if at end of string.  */
1052       if (*cp == '\0')
1053         break;
1054
1055       /* Take an arg.  */
1056       if (*cp == '"')
1057         {
1058           cp++;
1059           quoting = strchr (cp, '"') ? 1 : 0;
1060         }
1061
1062       *argv++ = cp;
1063
1064       /* Scan for next arg separator.  */
1065       pp = cp;
1066       if (quoting)
1067         cp = strchr (pp, '"');
1068       if ((cp == NULL) || (!quoting))
1069         cp = strchr (pp, ' ');
1070       if (cp == NULL)
1071         cp = strchr (pp, '\t');
1072       if (cp == NULL)
1073         cp = strchr (pp, '\n');
1074
1075       /* No separators => end of string => break.  */
1076       if (cp == NULL)
1077         {
1078           pp = cp;
1079           break;
1080         }
1081
1082       /* Replace the separator with a terminator.  */
1083       *cp++ = '\0';
1084     }
1085
1086   /* Execv requires a null-terminated arg vector.  */
1087   *argv = NULL;
1088 }
1089
1090 static void
1091 procfs_create_inferior (struct target_ops *ops, char *exec_file,
1092                         char *allargs, char **env, int from_tty)
1093 {
1094   struct inheritance inherit;
1095   pid_t pid;
1096   int flags, errn;
1097   char **argv, *args;
1098   const char *in = "", *out = "", *err = "";
1099   int fd, fds[3];
1100   sigset_t set;
1101   const char *inferior_io_terminal = get_inferior_io_terminal ();
1102   struct inferior *inf;
1103
1104   argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
1105                   sizeof (*argv));
1106   argv[0] = get_exec_file (1);
1107   if (!argv[0])
1108     {
1109       if (exec_file)
1110         argv[0] = exec_file;
1111       else
1112         return;
1113     }
1114
1115   args = xstrdup (allargs);
1116   breakup_args (args, exec_file ? &argv[1] : &argv[0]);
1117
1118   argv = nto_parse_redirection (argv, &in, &out, &err);
1119
1120   fds[0] = STDIN_FILENO;
1121   fds[1] = STDOUT_FILENO;
1122   fds[2] = STDERR_FILENO;
1123
1124   /* If the user specified I/O via gdb's --tty= arg, use it, but only
1125      if the i/o is not also being specified via redirection.  */
1126   if (inferior_io_terminal)
1127     {
1128       if (!in[0])
1129         in = inferior_io_terminal;
1130       if (!out[0])
1131         out = inferior_io_terminal;
1132       if (!err[0])
1133         err = inferior_io_terminal;
1134     }
1135
1136   if (in[0])
1137     {
1138       fd = open (in, O_RDONLY);
1139       if (fd == -1)
1140         perror (in);
1141       else
1142         fds[0] = fd;
1143     }
1144   if (out[0])
1145     {
1146       fd = open (out, O_WRONLY);
1147       if (fd == -1)
1148         perror (out);
1149       else
1150         fds[1] = fd;
1151     }
1152   if (err[0])
1153     {
1154       fd = open (err, O_WRONLY);
1155       if (fd == -1)
1156         perror (err);
1157       else
1158         fds[2] = fd;
1159     }
1160
1161   /* Clear any pending SIGUSR1's but keep the behavior the same.  */
1162   signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1163
1164   sigemptyset (&set);
1165   sigaddset (&set, SIGUSR1);
1166   sigprocmask (SIG_UNBLOCK, &set, NULL);
1167
1168   memset (&inherit, 0, sizeof (inherit));
1169
1170   if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1171     {
1172       inherit.nd = nto_node ();
1173       inherit.flags |= SPAWN_SETND;
1174       inherit.flags &= ~SPAWN_EXEC;
1175     }
1176   inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1177   inherit.pgroup = SPAWN_NEWPGROUP;
1178   pid = spawnp (argv[0], 3, fds, &inherit, argv,
1179                 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1180   xfree (args);
1181
1182   sigprocmask (SIG_BLOCK, &set, NULL);
1183
1184   if (pid == -1)
1185     error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1186            safe_strerror (errno));
1187
1188   if (fds[0] != STDIN_FILENO)
1189     close (fds[0]);
1190   if (fds[1] != STDOUT_FILENO)
1191     close (fds[1]);
1192   if (fds[2] != STDERR_FILENO)
1193     close (fds[2]);
1194
1195   inferior_ptid = do_attach (pid_to_ptid (pid));
1196   procfs_find_new_threads (ops);
1197
1198   inf = current_inferior ();
1199   inferior_appeared (inf, pid);
1200   inf->attach_flag = 0;
1201
1202   flags = _DEBUG_FLAG_KLC;      /* Kill-on-Last-Close flag.  */
1203   errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1204   if (errn != EOK)
1205     {
1206       /* FIXME: expected warning?  */
1207       /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1208          errn, strerror(errn) ); */
1209     }
1210   push_target (ops);
1211   target_terminal_init ();
1212
1213   if (exec_bfd != NULL
1214       || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1215     solib_create_inferior_hook (0);
1216 }
1217
1218 static void
1219 procfs_stop (ptid_t ptid)
1220 {
1221   devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1222 }
1223
1224 static void
1225 procfs_kill_inferior (struct target_ops *ops)
1226 {
1227   target_mourn_inferior ();
1228 }
1229
1230 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1231    of REGISTERS.  */
1232 static void
1233 procfs_prepare_to_store (struct target_ops *self, struct regcache *regcache)
1234 {
1235 }
1236
1237 /* Fill buf with regset and return devctl cmd to do the setting.  Return
1238    -1 if we fail to get the regset.  Store size of regset in regsize.  */
1239 static int
1240 get_regset (int regset, char *buf, int bufsize, int *regsize)
1241 {
1242   int dev_get, dev_set;
1243   switch (regset)
1244     {
1245     case NTO_REG_GENERAL:
1246       dev_get = DCMD_PROC_GETGREG;
1247       dev_set = DCMD_PROC_SETGREG;
1248       break;
1249
1250     case NTO_REG_FLOAT:
1251       dev_get = DCMD_PROC_GETFPREG;
1252       dev_set = DCMD_PROC_SETFPREG;
1253       break;
1254
1255     case NTO_REG_ALT:
1256       dev_get = DCMD_PROC_GETALTREG;
1257       dev_set = DCMD_PROC_SETALTREG;
1258       break;
1259
1260     case NTO_REG_SYSTEM:
1261     default:
1262       return -1;
1263     }
1264   if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1265     return -1;
1266
1267   return dev_set;
1268 }
1269
1270 void
1271 procfs_store_registers (struct target_ops *ops,
1272                         struct regcache *regcache, int regno)
1273 {
1274   union
1275   {
1276     procfs_greg greg;
1277     procfs_fpreg fpreg;
1278     procfs_altreg altreg;
1279   }
1280   reg;
1281   unsigned off;
1282   int len, regset, regsize, dev_set, err;
1283   char *data;
1284
1285   if (ptid_equal (inferior_ptid, null_ptid))
1286     return;
1287   procfs_set_thread (inferior_ptid);
1288
1289   if (regno == -1)
1290     {
1291       for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1292         {
1293           dev_set = get_regset (regset, (char *) &reg,
1294                                 sizeof (reg), &regsize);
1295           if (dev_set == -1)
1296             continue;
1297
1298           if (nto_regset_fill (regcache, regset, (char *) &reg) == -1)
1299             continue;
1300
1301           err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1302           if (err != EOK)
1303             fprintf_unfiltered (gdb_stderr,
1304                                 "Warning unable to write regset %d: %s\n",
1305                                 regno, safe_strerror (err));
1306         }
1307     }
1308   else
1309     {
1310       regset = nto_regset_id (regno);
1311       if (regset == -1)
1312         return;
1313
1314       dev_set = get_regset (regset, (char *) &reg, sizeof (reg), &regsize);
1315       if (dev_set == -1)
1316         return;
1317
1318       len = nto_register_area (get_regcache_arch (regcache),
1319                                regno, regset, &off);
1320
1321       if (len < 1)
1322         return;
1323
1324       regcache_raw_collect (regcache, regno, (char *) &reg + off);
1325
1326       err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1327       if (err != EOK)
1328         fprintf_unfiltered (gdb_stderr,
1329                             "Warning unable to write regset %d: %s\n", regno,
1330                             safe_strerror (err));
1331     }
1332 }
1333
1334 /* Set list of signals to be handled in the target.  */
1335
1336 static void
1337 procfs_pass_signals (int numsigs, unsigned char *pass_signals)
1338 {
1339   int signo;
1340
1341   sigfillset (&run.trace);
1342
1343   for (signo = 1; signo < NSIG; signo++)
1344     {
1345       int target_signo = gdb_signal_from_host (signo);
1346       if (target_signo < numsigs && pass_signals[target_signo])
1347         sigdelset (&run.trace, signo);
1348     }
1349 }
1350
1351 static struct tidinfo *
1352 procfs_thread_info (pid_t pid, short tid)
1353 {
1354 /* NYI */
1355   return NULL;
1356 }
1357
1358 static char *
1359 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
1360 {
1361   static char buf[1024];
1362   int pid, tid, n;
1363   struct tidinfo *tip;
1364
1365   pid = ptid_get_pid (ptid);
1366   tid = ptid_get_tid (ptid);
1367
1368   n = snprintf (buf, 1023, "process %d", pid);
1369
1370 #if 0                           /* NYI */
1371   tip = procfs_thread_info (pid, tid);
1372   if (tip != NULL)
1373     snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1374 #endif
1375
1376   return buf;
1377 }
1378
1379 static void
1380 init_procfs_ops (void)
1381 {
1382   procfs_ops.to_shortname = "procfs";
1383   procfs_ops.to_longname = "QNX Neutrino procfs child process";
1384   procfs_ops.to_doc =
1385     "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1386         target procfs <node>";
1387   procfs_ops.to_open = procfs_open;
1388   procfs_ops.to_attach = procfs_attach;
1389   procfs_ops.to_post_attach = procfs_post_attach;
1390   procfs_ops.to_detach = procfs_detach;
1391   procfs_ops.to_resume = procfs_resume;
1392   procfs_ops.to_wait = procfs_wait;
1393   procfs_ops.to_fetch_registers = procfs_fetch_registers;
1394   procfs_ops.to_store_registers = procfs_store_registers;
1395   procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
1396   procfs_ops.deprecated_xfer_memory = procfs_xfer_memory;
1397   procfs_ops.to_files_info = procfs_files_info;
1398   procfs_ops.to_insert_breakpoint = procfs_insert_breakpoint;
1399   procfs_ops.to_remove_breakpoint = procfs_remove_breakpoint;
1400   procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
1401   procfs_ops.to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
1402   procfs_ops.to_remove_hw_breakpoint = procfs_remove_breakpoint;
1403   procfs_ops.to_insert_watchpoint = procfs_insert_hw_watchpoint;
1404   procfs_ops.to_remove_watchpoint = procfs_remove_hw_watchpoint;
1405   procfs_ops.to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
1406   procfs_ops.to_terminal_init = terminal_init_inferior;
1407   procfs_ops.to_terminal_inferior = terminal_inferior;
1408   procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1409   procfs_ops.to_terminal_ours = terminal_ours;
1410   procfs_ops.to_terminal_info = child_terminal_info;
1411   procfs_ops.to_kill = procfs_kill_inferior;
1412   procfs_ops.to_create_inferior = procfs_create_inferior;
1413   procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
1414   procfs_ops.to_can_run = procfs_can_run;
1415   procfs_ops.to_pass_signals = procfs_pass_signals;
1416   procfs_ops.to_thread_alive = procfs_thread_alive;
1417   procfs_ops.to_find_new_threads = procfs_find_new_threads;
1418   procfs_ops.to_pid_to_str = procfs_pid_to_str;
1419   procfs_ops.to_stop = procfs_stop;
1420   procfs_ops.to_stratum = process_stratum;
1421   procfs_ops.to_has_all_memory = default_child_has_all_memory;
1422   procfs_ops.to_has_memory = default_child_has_memory;
1423   procfs_ops.to_has_stack = default_child_has_stack;
1424   procfs_ops.to_has_registers = default_child_has_registers;
1425   procfs_ops.to_has_execution = default_child_has_execution;
1426   procfs_ops.to_magic = OPS_MAGIC;
1427   procfs_ops.to_have_continuable_watchpoint = 1;
1428   procfs_ops.to_extra_thread_info = nto_extra_thread_info;
1429 }
1430
1431 #define OSTYPE_NTO 1
1432
1433 void
1434 _initialize_procfs (void)
1435 {
1436   sigset_t set;
1437
1438   init_procfs_ops ();
1439   add_target (&procfs_ops);
1440
1441   /* We use SIGUSR1 to gain control after we block waiting for a process.
1442      We use sigwaitevent to wait.  */
1443   sigemptyset (&set);
1444   sigaddset (&set, SIGUSR1);
1445   sigprocmask (SIG_BLOCK, &set, NULL);
1446
1447   /* Initially, make sure all signals are reported.  */
1448   sigfillset (&run.trace);
1449
1450   /* Stuff some information.  */
1451   nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1452   nto_cpuinfo_valid = 1;
1453
1454   add_info ("pidlist", procfs_pidlist, _("pidlist"));
1455   add_info ("meminfo", procfs_meminfo, _("memory information"));
1456
1457   nto_is_nto_target = procfs_is_nto_target;
1458 }
1459
1460
1461 static int
1462 procfs_hw_watchpoint (int addr, int len, int type)
1463 {
1464   procfs_break brk;
1465
1466   switch (type)
1467     {
1468     case 1:                     /* Read.  */
1469       brk.type = _DEBUG_BREAK_RD;
1470       break;
1471     case 2:                     /* Read/Write.  */
1472       brk.type = _DEBUG_BREAK_RW;
1473       break;
1474     default:                    /* Modify.  */
1475 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason.  */
1476       brk.type = _DEBUG_BREAK_RW;
1477     }
1478   brk.type |= _DEBUG_BREAK_HW;  /* Always ask for HW.  */
1479   brk.addr = addr;
1480   brk.size = len;
1481
1482   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1483   if (errno != EOK)
1484     {
1485       perror (_("Failed to set hardware watchpoint"));
1486       return -1;
1487     }
1488   return 0;
1489 }
1490
1491 static int
1492 procfs_can_use_hw_breakpoint (struct target_ops *self,
1493                               int type, int cnt, int othertype)
1494 {
1495   return 1;
1496 }
1497
1498 static int
1499 procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type,
1500                              struct expression *cond)
1501 {
1502   return procfs_hw_watchpoint (addr, -1, type);
1503 }
1504
1505 static int
1506 procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type,
1507                              struct expression *cond)
1508 {
1509   return procfs_hw_watchpoint (addr, len, type);
1510 }
1511
1512 static int
1513 procfs_stopped_by_watchpoint (struct target_ops *ops)
1514 {
1515   return 0;
1516 }