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