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