gdb/nto-procfs.c

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