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