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