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