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