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