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