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   std::string 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).c_str (),
 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)).c_str ());
 712       else
 713         printf_unfiltered ("Attaching to %s\n",
 714                            target_pid_to_str (ptid_t (pid)).c_str ());
 715     }
 716   inferior_ptid = do_attach (ptid_t (pid));
 717   inf = current_inferior ();
 718   inferior_appeared (inf, pid);
 719   inf->attach_flag = 1;
 720
 721   if (!target_is_pushed (ops))
 722     push_target (ops);
 723
 724   procfs_update_thread_list (ops);
 725 }
 726
 727 void
 728 nto_procfs_target::post_attach (pid_t pid)
 729 {
 730   if (exec_bfd)
 731     solib_create_inferior_hook (0);
 732 }
 733
 734 static ptid_t
 735 do_attach (ptid_t ptid)
 736 {
 737   procfs_status status;
 738   struct sigevent event;
 739   char path[PATH_MAX];
 740
 741   snprintf (path, PATH_MAX - 1, "%s%s/%d/as",
 742             (nodestr != NULL) ? nodestr : "", "/proc", ptid.pid ());
 743   ctl_fd = open (path, O_RDWR);
 744   if (ctl_fd == -1)
 745     error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
 746            safe_strerror (errno));
 747   if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
 748     error (_("Couldn't stop process"));
 749
 750   /* Define a sigevent for process stopped notification.  */
 751   event.sigev_notify = SIGEV_SIGNAL_THREAD;
 752   event.sigev_signo = SIGUSR1;
 753   event.sigev_code = 0;
 754   event.sigev_value.sival_ptr = NULL;
 755   event.sigev_priority = -1;
 756   devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
 757
 758   if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
 759       && status.flags & _DEBUG_FLAG_STOPPED)
 760     SignalKill (nto_node (), ptid.pid (), 0, SIGCONT, 0, 0);
 761   nto_init_solib_absolute_prefix ();
 762   return ptid_t (ptid.pid (), 0, status.tid);
 763 }
 764
 765 /* Ask the user what to do when an interrupt is received.  */
 766 static void
 767 interrupt_query (void)
 768 {
 769   if (query (_("Interrupted while waiting for the program.\n\
 770 Give up (and stop debugging it)? ")))
 771     {
 772       target_mourn_inferior (inferior_ptid);
 773       quit ();
 774     }
 775 }
 776
 777 /* The user typed ^C twice.  */
 778 static void
 779 nto_handle_sigint_twice (int signo)
 780 {
 781   signal (signo, ofunc);
 782   interrupt_query ();
 783   signal (signo, nto_handle_sigint_twice);
 784 }
 785
 786 static void
 787 nto_handle_sigint (int signo)
 788 {
 789   /* If this doesn't work, try more severe steps.  */
 790   signal (signo, nto_handle_sigint_twice);
 791
 792   target_interrupt ();
 793 }
 794
 795 sptid_t
 796 nto_procfs_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
 797                          int options)
 798 {
 799   sigset_t set;
 800   siginfo_t info;
 801   procfs_status status;
 802   static int exit_signo = 0;    /* To track signals that cause termination.  */
 803
 804   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 805
 806   if (inferior_ptid == null_ptid)
 807     {
 808       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 809       ourstatus->value.sig = GDB_SIGNAL_0;
 810       exit_signo = 0;
 811       return null_ptid;
 812     }
 813
 814   sigemptyset (&set);
 815   sigaddset (&set, SIGUSR1);
 816
 817   devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 818   while (!(status.flags & _DEBUG_FLAG_ISTOP))
 819     {
 820       ofunc = signal (SIGINT, nto_handle_sigint);
 821       sigwaitinfo (&set, &info);
 822       signal (SIGINT, ofunc);
 823       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 824     }
 825
 826   nto_inferior_data (NULL)->stopped_flags = status.flags;
 827   nto_inferior_data (NULL)->stopped_pc = status.ip;
 828
 829   if (status.flags & _DEBUG_FLAG_SSTEP)
 830     {
 831       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 832       ourstatus->value.sig = GDB_SIGNAL_TRAP;
 833     }
 834   /* Was it a breakpoint?  */
 835   else if (status.flags & _DEBUG_FLAG_TRACE)
 836     {
 837       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 838       ourstatus->value.sig = GDB_SIGNAL_TRAP;
 839     }
 840   else if (status.flags & _DEBUG_FLAG_ISTOP)
 841     {
 842       switch (status.why)
 843         {
 844         case _DEBUG_WHY_SIGNALLED:
 845           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 846           ourstatus->value.sig =
 847             gdb_signal_from_host (status.info.si_signo);
 848           exit_signo = 0;
 849           break;
 850         case _DEBUG_WHY_FAULTED:
 851           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 852           if (status.info.si_signo == SIGTRAP)
 853             {
 854               ourstatus->value.sig = 0;
 855               exit_signo = 0;
 856             }
 857           else
 858             {
 859               ourstatus->value.sig =
 860                 gdb_signal_from_host (status.info.si_signo);
 861               exit_signo = ourstatus->value.sig;
 862             }
 863           break;
 864
 865         case _DEBUG_WHY_TERMINATED:
 866           {
 867             int waitval = 0;
 868
 869             waitpid (inferior_ptid.pid (), &waitval, WNOHANG);
 870             if (exit_signo)
 871               {
 872                 /* Abnormal death.  */
 873                 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 874                 ourstatus->value.sig = exit_signo;
 875               }
 876             else
 877               {
 878                 /* Normal death.  */
 879                 ourstatus->kind = TARGET_WAITKIND_EXITED;
 880                 ourstatus->value.integer = WEXITSTATUS (waitval);
 881               }
 882             exit_signo = 0;
 883             break;
 884           }
 885
 886         case _DEBUG_WHY_REQUESTED:
 887           /* We are assuming a requested stop is due to a SIGINT.  */
 888           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 889           ourstatus->value.sig = GDB_SIGNAL_INT;
 890           exit_signo = 0;
 891           break;
 892         }
 893     }
 894
 895   return ptid_t (status.pid, 0, status.tid);
 896 }
 897
 898 /* Read the current values of the inferior's registers, both the
 899    general register set and floating point registers (if supported)
 900    and update gdb's idea of their current values.  */
 901 void
 902 nto_procfs_target::fetch_registers (struct regcache *regcache, int regno)
 903 {
 904   union
 905   {
 906     procfs_greg greg;
 907     procfs_fpreg fpreg;
 908     procfs_altreg altreg;
 909   }
 910   reg;
 911   int regsize;
 912
 913   procfs_set_thread (regcache->ptid ());
 914   if (devctl (ctl_fd, DCMD_PROC_GETGREG, &reg, sizeof (reg), &regsize) == EOK)
 915     nto_supply_gregset (regcache, (char *) &reg.greg);
 916   if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
 917       == EOK)
 918     nto_supply_fpregset (regcache, (char *) &reg.fpreg);
 919   if (devctl (ctl_fd, DCMD_PROC_GETALTREG, &reg, sizeof (reg), &regsize)
 920       == EOK)
 921     nto_supply_altregset (regcache, (char *) &reg.altreg);
 922 }
 923
 924 /* Helper for procfs_xfer_partial that handles memory transfers.
 925    Arguments are like target_xfer_partial.  */
 926
 927 static enum target_xfer_status
 928 procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
 929                     ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
 930 {
 931   int nbytes;
 932
 933   if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr)
 934     return TARGET_XFER_E_IO;
 935
 936   if (writebuf != NULL)
 937     nbytes = write (ctl_fd, writebuf, len);
 938   else
 939     nbytes = read (ctl_fd, readbuf, len);
 940   if (nbytes <= 0)
 941     return TARGET_XFER_E_IO;
 942   *xfered_len = nbytes;
 943   return TARGET_XFER_OK;
 944 }
 945
 946 /* Target to_xfer_partial implementation.  */
 947
 948 enum target_xfer_status
 949 nto_procfs_target::xfer_partial (enum target_object object,
 950                                  const char *annex, gdb_byte *readbuf,
 951                                  const gdb_byte *writebuf, ULONGEST offset,
 952                                  ULONGEST len, ULONGEST *xfered_len)
 953 {
 954   switch (object)
 955     {
 956     case TARGET_OBJECT_MEMORY:
 957       return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
 958     case TARGET_OBJECT_AUXV:
 959       if (readbuf != NULL)
 960         {
 961           int err;
 962           CORE_ADDR initial_stack;
 963           debug_process_t procinfo;
 964           /* For 32-bit architecture, size of auxv_t is 8 bytes.  */
 965           const unsigned int sizeof_auxv_t = sizeof (auxv_t);
 966           const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t;
 967           int tempread;
 968           gdb_byte *const tempbuf = alloca (sizeof_tempbuf);
 969
 970           if (tempbuf == NULL)
 971             return TARGET_XFER_E_IO;
 972
 973           err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo,
 974                         sizeof procinfo, 0);
 975           if (err != EOK)
 976             return TARGET_XFER_E_IO;
 977
 978           initial_stack = procinfo.initial_stack;
 979
 980           /* procfs is always 'self-hosted', no byte-order manipulation.  */
 981           tempread = nto_read_auxv_from_initial_stack (initial_stack, tempbuf,
 982                                                        sizeof_tempbuf,
 983                                                        sizeof (auxv_t));
 984           tempread = std::min (tempread, len) - offset;
 985           memcpy (readbuf, tempbuf + offset, tempread);
 986           *xfered_len = tempread;
 987           return tempread ? TARGET_XFER_OK : TARGET_XFER_EOF;
 988         }
 989         /* Fallthru */
 990     default:
 991       return this->beneath ()->xfer_partial (object, annex,
 992                                              readbuf, writebuf, offset, len,
 993                                              xfered_len);
 994     }
 995 }
 996
 997 /* Take a program previously attached to and detaches it.
 998    The program resumes execution and will no longer stop
 999    on signals, etc.  We'd better not have left any breakpoints
1000    in the program or it'll die when it hits one.  */
1001 void
1002 nto_procfs_target::detach (inferior *inf, int from_tty)
1003 {
1004   int pid;
1005
1006   target_announce_detach ();
1007
1008   if (siggnal)
1009     SignalKill (nto_node (), inferior_ptid.pid (), 0, 0, 0, 0);
1010
1011   close (ctl_fd);
1012   ctl_fd = -1;
1013
1014   pid = inferior_ptid.pid ();
1015   inferior_ptid = null_ptid;
1016   detach_inferior (pid);
1017   init_thread_list ();
1018   inf_child_maybe_unpush_target (ops);
1019 }
1020
1021 static int
1022 procfs_breakpoint (CORE_ADDR addr, int type, int size)
1023 {
1024   procfs_break brk;
1025
1026   brk.type = type;
1027   brk.addr = addr;
1028   brk.size = size;
1029   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1030   if (errno != EOK)
1031     return 1;
1032   return 0;
1033 }
1034
1035 int
1036 nto_procfs_target::insert_breakpoint (struct gdbarch *gdbarch,
1037                                       struct bp_target_info *bp_tgt)
1038 {
1039   bp_tgt->placed_address = bp_tgt->reqstd_address;
1040   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
1041 }
1042
1043 int
1044 nto_procfs_target::remove_breakpoint (struct gdbarch *gdbarch,
1045                                       struct bp_target_info *bp_tgt,
1046                                       enum remove_bp_reason reason)
1047 {
1048   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
1049 }
1050
1051 int
1052 nto_procfs_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
1053                                          struct bp_target_info *bp_tgt)
1054 {
1055   bp_tgt->placed_address = bp_tgt->reqstd_address;
1056   return procfs_breakpoint (bp_tgt->placed_address,
1057                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
1058 }
1059
1060 int
1061 nto_procfs_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
1062                                          struct bp_target_info *bp_tgt)
1063 {
1064   return procfs_breakpoint (bp_tgt->placed_address,
1065                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
1066 }
1067
1068 void
1069 nto_procfs_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
1070 {
1071   int signal_to_pass;
1072   procfs_status status;
1073   sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
1074
1075   if (inferior_ptid == null_ptid)
1076     return;
1077
1078   procfs_set_thread (ptid == minus_one_ptid ? inferior_ptid :
1079                      ptid);
1080
1081   run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
1082   if (step)
1083     run.flags |= _DEBUG_RUN_STEP;
1084
1085   sigemptyset (run_fault);
1086   sigaddset (run_fault, FLTBPT);
1087   sigaddset (run_fault, FLTTRACE);
1088   sigaddset (run_fault, FLTILL);
1089   sigaddset (run_fault, FLTPRIV);
1090   sigaddset (run_fault, FLTBOUNDS);
1091   sigaddset (run_fault, FLTIOVF);
1092   sigaddset (run_fault, FLTIZDIV);
1093   sigaddset (run_fault, FLTFPE);
1094   /* Peter V will be changing this at some point.  */
1095   sigaddset (run_fault, FLTPAGE);
1096
1097   run.flags |= _DEBUG_RUN_ARM;
1098
1099   signal_to_pass = gdb_signal_to_host (signo);
1100
1101   if (signal_to_pass)
1102     {
1103       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
1104       signal_to_pass = gdb_signal_to_host (signo);
1105       if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
1106         {
1107           if (signal_to_pass != status.info.si_signo)
1108             {
1109               SignalKill (nto_node (), inferior_ptid.pid (), 0,
1110                           signal_to_pass, 0, 0);
1111               run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1112             }
1113           else          /* Let it kill the program without telling us.  */
1114             sigdelset (&run.trace, signal_to_pass);
1115         }
1116     }
1117   else
1118     run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1119
1120   errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1121   if (errno != EOK)
1122     {
1123       perror (_("run error!\n"));
1124       return;
1125     }
1126 }
1127
1128 void
1129 nto_procfs_target::mourn_inferior ()
1130 {
1131   if (inferior_ptid != null_ptid)
1132     {
1133       SignalKill (nto_node (), inferior_ptid.pid (), 0, SIGKILL, 0, 0);
1134       close (ctl_fd);
1135     }
1136   inferior_ptid = null_ptid;
1137   init_thread_list ();
1138   inf_child_mourn_inferior (ops);
1139 }
1140
1141 /* This function breaks up an argument string into an argument
1142    vector suitable for passing to execvp().
1143    E.g., on "run a b c d" this routine would get as input
1144    the string "a b c d", and as output it would fill in argv with
1145    the four arguments "a", "b", "c", "d".  The only additional
1146    functionality is simple quoting.  The gdb command:
1147         run a "b c d" f
1148    will fill in argv with the three args "a", "b c d", "e".  */
1149 static void
1150 breakup_args (char *scratch, char **argv)
1151 {
1152   char *pp, *cp = scratch;
1153   char quoting = 0;
1154
1155   for (;;)
1156     {
1157       /* Scan past leading separators.  */
1158       quoting = 0;
1159       while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1160         cp++;
1161
1162       /* Break if at end of string.  */
1163       if (*cp == '\0')
1164         break;
1165
1166       /* Take an arg.  */
1167       if (*cp == '"')
1168         {
1169           cp++;
1170           quoting = strchr (cp, '"') ? 1 : 0;
1171         }
1172
1173       *argv++ = cp;
1174
1175       /* Scan for next arg separator.  */
1176       pp = cp;
1177       if (quoting)
1178         cp = strchr (pp, '"');
1179       if ((cp == NULL) || (!quoting))
1180         cp = strchr (pp, ' ');
1181       if (cp == NULL)
1182         cp = strchr (pp, '\t');
1183       if (cp == NULL)
1184         cp = strchr (pp, '\n');
1185
1186       /* No separators => end of string => break.  */
1187       if (cp == NULL)
1188         {
1189           pp = cp;
1190           break;
1191         }
1192
1193       /* Replace the separator with a terminator.  */
1194       *cp++ = '\0';
1195     }
1196
1197   /* Execv requires a null-terminated arg vector.  */
1198   *argv = NULL;
1199 }
1200
1201 void
1202 nto_procfs_target::create_inferior (const char *exec_file,
1203                                     const std::string &allargs,
1204                                     char **env, int from_tty)
1205 {
1206   struct inheritance inherit;
1207   pid_t pid;
1208   int flags, errn;
1209   char **argv, *args;
1210   const char *in = "", *out = "", *err = "";
1211   int fd, fds[3];
1212   sigset_t set;
1213   const char *inferior_io_terminal = get_inferior_io_terminal ();
1214   struct inferior *inf;
1215
1216   argv = xmalloc ((allargs.size () / (unsigned) 2 + 2) *
1217                   sizeof (*argv));
1218   argv[0] = get_exec_file (1);
1219   if (!argv[0])
1220     {
1221       if (exec_file)
1222         argv[0] = exec_file;
1223       else
1224         return;
1225     }
1226
1227   args = xstrdup (allargs.c_str ());
1228   breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]);
1229
1230   argv = nto_parse_redirection (argv, &in, &out, &err);
1231
1232   fds[0] = STDIN_FILENO;
1233   fds[1] = STDOUT_FILENO;
1234   fds[2] = STDERR_FILENO;
1235
1236   /* If the user specified I/O via gdb's --tty= arg, use it, but only
1237      if the i/o is not also being specified via redirection.  */
1238   if (inferior_io_terminal)
1239     {
1240       if (!in[0])
1241         in = inferior_io_terminal;
1242       if (!out[0])
1243         out = inferior_io_terminal;
1244       if (!err[0])
1245         err = inferior_io_terminal;
1246     }
1247
1248   if (in[0])
1249     {
1250       fd = open (in, O_RDONLY);
1251       if (fd == -1)
1252         perror (in);
1253       else
1254         fds[0] = fd;
1255     }
1256   if (out[0])
1257     {
1258       fd = open (out, O_WRONLY);
1259       if (fd == -1)
1260         perror (out);
1261       else
1262         fds[1] = fd;
1263     }
1264   if (err[0])
1265     {
1266       fd = open (err, O_WRONLY);
1267       if (fd == -1)
1268         perror (err);
1269       else
1270         fds[2] = fd;
1271     }
1272
1273   /* Clear any pending SIGUSR1's but keep the behavior the same.  */
1274   signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1275
1276   sigemptyset (&set);
1277   sigaddset (&set, SIGUSR1);
1278   sigprocmask (SIG_UNBLOCK, &set, NULL);
1279
1280   memset (&inherit, 0, sizeof (inherit));
1281
1282   if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1283     {
1284       inherit.nd = nto_node ();
1285       inherit.flags |= SPAWN_SETND;
1286       inherit.flags &= ~SPAWN_EXEC;
1287     }
1288   inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1289   inherit.pgroup = SPAWN_NEWPGROUP;
1290   pid = spawnp (argv[0], 3, fds, &inherit, argv,
1291                 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1292   xfree (args);
1293
1294   sigprocmask (SIG_BLOCK, &set, NULL);
1295
1296   if (pid == -1)
1297     error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1298            safe_strerror (errno));
1299
1300   if (fds[0] != STDIN_FILENO)
1301     close (fds[0]);
1302   if (fds[1] != STDOUT_FILENO)
1303     close (fds[1]);
1304   if (fds[2] != STDERR_FILENO)
1305     close (fds[2]);
1306
1307   inferior_ptid = do_attach (ptid_t (pid));
1308   procfs_update_thread_list (ops);
1309
1310   inf = current_inferior ();
1311   inferior_appeared (inf, pid);
1312   inf->attach_flag = 0;
1313
1314   flags = _DEBUG_FLAG_KLC;      /* Kill-on-Last-Close flag.  */
1315   errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1316   if (errn != EOK)
1317     {
1318       /* FIXME: expected warning?  */
1319       /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1320          errn, strerror(errn) ); */
1321     }
1322   if (!target_is_pushed (ops))
1323     push_target (ops);
1324   target_terminal::init ();
1325
1326   if (exec_bfd != NULL
1327       || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1328     solib_create_inferior_hook (0);
1329 }
1330
1331 void
1332 nto_procfs_target::interrupt ()
1333 {
1334   devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1335 }
1336
1337 void
1338 nto_procfs_target::kill ()
1339 {
1340   target_mourn_inferior (inferior_ptid);
1341 }
1342
1343 /* Fill buf with regset and return devctl cmd to do the setting.  Return
1344    -1 if we fail to get the regset.  Store size of regset in regsize.  */
1345 static int
1346 get_regset (int regset, char *buf, int bufsize, int *regsize)
1347 {
1348   int dev_get, dev_set;
1349   switch (regset)
1350     {
1351     case NTO_REG_GENERAL:
1352       dev_get = DCMD_PROC_GETGREG;
1353       dev_set = DCMD_PROC_SETGREG;
1354       break;
1355
1356     case NTO_REG_FLOAT:
1357       dev_get = DCMD_PROC_GETFPREG;
1358       dev_set = DCMD_PROC_SETFPREG;
1359       break;
1360
1361     case NTO_REG_ALT:
1362       dev_get = DCMD_PROC_GETALTREG;
1363       dev_set = DCMD_PROC_SETALTREG;
1364       break;
1365
1366     case NTO_REG_SYSTEM:
1367     default:
1368       return -1;
1369     }
1370   if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1371     return -1;
1372
1373   return dev_set;
1374 }
1375
1376 void
1377 nto_procfs_target::store_registers (struct regcache *regcache, int regno)
1378 {
1379   union
1380   {
1381     procfs_greg greg;
1382     procfs_fpreg fpreg;
1383     procfs_altreg altreg;
1384   }
1385   reg;
1386   unsigned off;
1387   int len, regset, regsize, dev_set, err;
1388   char *data;
1389   ptid_t ptid = regcache->ptid ();
1390
1391   if (ptid == null_ptid)
1392     return;
1393   procfs_set_thread (ptid);
1394
1395   if (regno == -1)
1396     {
1397       for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1398         {
1399           dev_set = get_regset (regset, (char *) &reg,
1400                                 sizeof (reg), &regsize);
1401           if (dev_set == -1)
1402             continue;
1403
1404           if (nto_regset_fill (regcache, regset, (char *) &reg) == -1)
1405             continue;
1406
1407           err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1408           if (err != EOK)
1409             fprintf_unfiltered (gdb_stderr,
1410                                 "Warning unable to write regset %d: %s\n",
1411                                 regno, safe_strerror (err));
1412         }
1413     }
1414   else
1415     {
1416       regset = nto_regset_id (regno);
1417       if (regset == -1)
1418         return;
1419
1420       dev_set = get_regset (regset, (char *) &reg, sizeof (reg), &regsize);
1421       if (dev_set == -1)
1422         return;
1423
1424       len = nto_register_area (regcache->arch (),
1425                                regno, regset, &off);
1426
1427       if (len < 1)
1428         return;
1429
1430       regcache->raw_collect (regno, (char *) &reg + off);
1431
1432       err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1433       if (err != EOK)
1434         fprintf_unfiltered (gdb_stderr,
1435                             "Warning unable to write regset %d: %s\n", regno,
1436                             safe_strerror (err));
1437     }
1438 }
1439
1440 /* Set list of signals to be handled in the target.  */
1441
1442 void
1443 nto_procfs_target::pass_signals
1444   (gdb::array_view<const unsigned char> pass_signals)
1445 {
1446   int signo;
1447
1448   sigfillset (&run.trace);
1449
1450   for (signo = 1; signo < NSIG; signo++)
1451     {
1452       int target_signo = gdb_signal_from_host (signo);
1453       if (target_signo < pass_signals.size () && pass_signals[target_signo])
1454         sigdelset (&run.trace, signo);
1455     }
1456 }
1457
1458 std::string
1459 nto_procfs_target::pid_to_str (ptid_t ptid)
1460 {
1461   int pid, tid;
1462   struct tidinfo *tip;
1463
1464   pid = ptid.pid ();
1465   tid = ptid.tid ();
1466
1467 #if 0                           /* NYI */
1468   tip = procfs_thread_info (pid, tid);
1469   if (tip != NULL)
1470     snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1471 #endif
1472
1473   return string_printf ("process %d", pid);
1474 }
1475
1476 /* to_can_run implementation for "target procfs".  Note this really
1477   means "can this target be the default run target", which there can
1478   be only one, and we make it be "target native" like other ports.
1479   "target procfs <node>" wouldn't make sense as default run target, as
1480   it needs <node>.  */
1481
1482 int
1483 nto_procfs_target::can_run ()
1484 {
1485   return 0;
1486 }
1487
1488 /* "target procfs".  */
1489 static nto_procfs_target_procfs nto_procfs_ops;
1490
1491 /* "target native".  */
1492 static nto_procfs_target_native nto_native_ops;
1493
1494 /* Create the "native" and "procfs" targets.  */
1495
1496 static void
1497 init_procfs_targets (void)
1498 {
1499   /* Register "target native".  This is the default run target.  */
1500   add_target (nto_native_target_info, inf_child_open_target);
1501   set_native_target (&nto_native_ops);
1502
1503   /* Register "target procfs <node>".  */
1504   add_target (nto_procfs_target_info, inf_child_open_target);
1505 }
1506
1507 #define OSTYPE_NTO 1
1508
1509 void
1510 _initialize_procfs (void)
1511 {
1512   sigset_t set;
1513
1514   init_procfs_targets ();
1515
1516   /* We use SIGUSR1 to gain control after we block waiting for a process.
1517      We use sigwaitevent to wait.  */
1518   sigemptyset (&set);
1519   sigaddset (&set, SIGUSR1);
1520   sigprocmask (SIG_BLOCK, &set, NULL);
1521
1522   /* Initially, make sure all signals are reported.  */
1523   sigfillset (&run.trace);
1524
1525   /* Stuff some information.  */
1526   nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1527   nto_cpuinfo_valid = 1;
1528
1529   add_info ("pidlist", procfs_pidlist, _("pidlist"));
1530   add_info ("meminfo", procfs_meminfo, _("memory information"));
1531
1532   nto_is_nto_target = procfs_is_nto_target;
1533 }
1534
1535
1536 static int
1537 procfs_hw_watchpoint (int addr, int len, enum target_hw_bp_type type)
1538 {
1539   procfs_break brk;
1540
1541   switch (type)
1542     {
1543     case hw_read:
1544       brk.type = _DEBUG_BREAK_RD;
1545       break;
1546     case hw_access:
1547       brk.type = _DEBUG_BREAK_RW;
1548       break;
1549     default:                    /* Modify.  */
1550 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason.  */
1551       brk.type = _DEBUG_BREAK_RW;
1552     }
1553   brk.type |= _DEBUG_BREAK_HW;  /* Always ask for HW.  */
1554   brk.addr = addr;
1555   brk.size = len;
1556
1557   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1558   if (errno != EOK)
1559     {
1560       perror (_("Failed to set hardware watchpoint"));
1561       return -1;
1562     }
1563   return 0;
1564 }
1565
1566 bool
1567 nto_procfs_target::can_use_hw_breakpoint (enum bptype type,
1568                                           int cnt, int othertype)
1569 {
1570   return 1;
1571 }
1572
1573 int
1574 nto_procfs_target::remove_hw_watchpoint (CORE_ADDR addr, int len,
1575                                          enum target_hw_bp_type type,
1576                                          struct expression *cond)
1577 {
1578   return procfs_hw_watchpoint (addr, -1, type);
1579 }
1580
1581 int
1582 nto_procfs_target::insert_hw_watchpoint (CORE_ADDR addr, int len,
1583                                          enum target_hw_bp_type type,
1584                                          struct expression *cond)
1585 {
1586   return procfs_hw_watchpoint (addr, len, type);
1587 }
1588
1589 bool
1590 nto_procfs_target::stopped_by_watchpoint ()
1591 {
1592   /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are
1593      stopped due to a SIGTRAP.  This assumes gdb works in 'all-stop' mode;
1594      future gdb versions will likely run in 'non-stop' mode in which case
1595      we will have to store/examine statuses per thread in question.
1596      Until then, this will work fine.  */
1597
1598   struct inferior *inf = current_inferior ();
1599   struct nto_inferior_data *inf_data;
1600
1601   gdb_assert (inf != NULL);
1602
1603   inf_data = nto_inferior_data (inf);
1604
1605   return inf_data->stopped_flags
1606          & (_DEBUG_FLAG_TRACE_RD
1607             | _DEBUG_FLAG_TRACE_WR
1608             | _DEBUG_FLAG_TRACE_MODIFY);
1609 }