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   printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
 498                      attach_flag ? "attached" : "child",
 499                      target_pid_to_str (inferior_ptid), nto_procfs_path);
 500 }
 501
 502 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
 503 static int
 504 procfs_can_run (void)
 505 {
 506   return 1;
 507 }
 508
 509 /* Attach to process PID, then initialize for debugging it.  */
 510 static void
 511 procfs_attach (char *args, int from_tty)
 512 {
 513   char *exec_file;
 514   int pid;
 515
 516   if (!args)
 517     error_no_arg (_("process-id to attach"));
 518
 519   pid = atoi (args);
 520
 521   if (pid == getpid ())
 522     error (_("Attaching GDB to itself is not a good idea..."));
 523
 524   if (from_tty)
 525     {
 526       exec_file = (char *) get_exec_file (0);
 527
 528       if (exec_file)
 529         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
 530                            target_pid_to_str (pid_to_ptid (pid)));
 531       else
 532         printf_unfiltered ("Attaching to %s\n",
 533                            target_pid_to_str (pid_to_ptid (pid)));
 534
 535       gdb_flush (gdb_stdout);
 536     }
 537   inferior_ptid = do_attach (pid_to_ptid (pid));
 538   push_target (&procfs_ops);
 539 }
 540
 541 static void
 542 procfs_post_attach (pid_t pid)
 543 {
 544   if (exec_bfd)
 545     solib_create_inferior_hook ();
 546 }
 547
 548 static ptid_t
 549 do_attach (ptid_t ptid)
 550 {
 551   procfs_status status;
 552   struct sigevent event;
 553   char path[PATH_MAX];
 554
 555   snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path, PIDGET (ptid));
 556   ctl_fd = open (path, O_RDWR);
 557   if (ctl_fd == -1)
 558     error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
 559            safe_strerror (errno));
 560   if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
 561     error (_("Couldn't stop process"));
 562
 563   /* Define a sigevent for process stopped notification.  */
 564   event.sigev_notify = SIGEV_SIGNAL_THREAD;
 565   event.sigev_signo = SIGUSR1;
 566   event.sigev_code = 0;
 567   event.sigev_value.sival_ptr = NULL;
 568   event.sigev_priority = -1;
 569   devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
 570
 571   if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
 572       && status.flags & _DEBUG_FLAG_STOPPED)
 573     SignalKill (nto_node (), PIDGET (ptid), 0, SIGCONT, 0, 0);
 574   attach_flag = 1;
 575   nto_init_solib_absolute_prefix ();
 576   return ptid;
 577 }
 578
 579 /* Ask the user what to do when an interrupt is received.  */
 580 static void
 581 interrupt_query (void)
 582 {
 583   target_terminal_ours ();
 584
 585   if (query ("Interrupted while waiting for the program.\n\
 586 Give up (and stop debugging it)? "))
 587     {
 588       target_mourn_inferior ();
 589       deprecated_throw_reason (RETURN_QUIT);
 590     }
 591
 592   target_terminal_inferior ();
 593 }
 594
 595 /* The user typed ^C twice.  */
 596 static void
 597 nto_interrupt_twice (int signo)
 598 {
 599   signal (signo, ofunc);
 600   interrupt_query ();
 601   signal (signo, nto_interrupt_twice);
 602 }
 603
 604 static void
 605 nto_interrupt (int signo)
 606 {
 607   /* If this doesn't work, try more severe steps.  */
 608   signal (signo, nto_interrupt_twice);
 609
 610   target_stop (inferior_ptid);
 611 }
 612
 613 static ptid_t
 614 procfs_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 615 {
 616   sigset_t set;
 617   siginfo_t info;
 618   procfs_status status;
 619   static int exit_signo = 0;    /* To track signals that cause termination.  */
 620
 621   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 622
 623   if (ptid_equal (inferior_ptid, null_ptid))
 624     {
 625       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 626       ourstatus->value.sig = TARGET_SIGNAL_0;
 627       exit_signo = 0;
 628       return null_ptid;
 629     }
 630
 631   sigemptyset (&set);
 632   sigaddset (&set, SIGUSR1);
 633
 634   devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 635   while (!(status.flags & _DEBUG_FLAG_ISTOP))
 636     {
 637       ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
 638       sigwaitinfo (&set, &info);
 639       signal (SIGINT, ofunc);
 640       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 641     }
 642
 643   if (status.flags & _DEBUG_FLAG_SSTEP)
 644     {
 645       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 646       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 647     }
 648   /* Was it a breakpoint?  */
 649   else if (status.flags & _DEBUG_FLAG_TRACE)
 650     {
 651       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 652       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 653     }
 654   else if (status.flags & _DEBUG_FLAG_ISTOP)
 655     {
 656       switch (status.why)
 657         {
 658         case _DEBUG_WHY_SIGNALLED:
 659           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 660           ourstatus->value.sig =
 661             target_signal_from_host (status.info.si_signo);
 662           exit_signo = 0;
 663           break;
 664         case _DEBUG_WHY_FAULTED:
 665           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 666           if (status.info.si_signo == SIGTRAP)
 667             {
 668               ourstatus->value.sig = 0;
 669               exit_signo = 0;
 670             }
 671           else
 672             {
 673               ourstatus->value.sig =
 674                 target_signal_from_host (status.info.si_signo);
 675               exit_signo = ourstatus->value.sig;
 676             }
 677           break;
 678
 679         case _DEBUG_WHY_TERMINATED:
 680           {
 681             int waitval = 0;
 682
 683             waitpid (PIDGET (inferior_ptid), &waitval, WNOHANG);
 684             if (exit_signo)
 685               {
 686                 /* Abnormal death.  */
 687                 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 688                 ourstatus->value.sig = exit_signo;
 689               }
 690             else
 691               {
 692                 /* Normal death.  */
 693                 ourstatus->kind = TARGET_WAITKIND_EXITED;
 694                 ourstatus->value.integer = WEXITSTATUS (waitval);
 695               }
 696             exit_signo = 0;
 697             break;
 698           }
 699
 700         case _DEBUG_WHY_REQUESTED:
 701           /* We are assuming a requested stop is due to a SIGINT.  */
 702           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 703           ourstatus->value.sig = TARGET_SIGNAL_INT;
 704           exit_signo = 0;
 705           break;
 706         }
 707     }
 708
 709   return inferior_ptid;
 710 }
 711
 712 /* Read the current values of the inferior's registers, both the
 713    general register set and floating point registers (if supported)
 714    and update gdb's idea of their current values.  */
 715 static void
 716 procfs_fetch_registers (struct regcache *regcache, int regno)
 717 {
 718   union
 719   {
 720     procfs_greg greg;
 721     procfs_fpreg fpreg;
 722     procfs_altreg altreg;
 723   }
 724   reg;
 725   int regsize;
 726
 727   procfs_set_thread (inferior_ptid);
 728   if (devctl (ctl_fd, DCMD_PROC_GETGREG, &reg, sizeof (reg), &regsize) == EOK)
 729     nto_supply_gregset (regcache, (char *) &reg.greg);
 730   if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
 731       == EOK)
 732     nto_supply_fpregset (regcache, (char *) &reg.fpreg);
 733   if (devctl (ctl_fd, DCMD_PROC_GETALTREG, &reg, sizeof (reg), &regsize)
 734       == EOK)
 735     nto_supply_altregset (regcache, (char *) &reg.altreg);
 736 }
 737
 738 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
 739    from/to debugger memory starting at MYADDR.  Copy from inferior
 740    if DOWRITE is zero or to inferior if DOWRITE is nonzero.
 741
 742    Returns the length copied, which is either the LEN argument or
 743    zero.  This xfer function does not do partial moves, since procfs_ops
 744    doesn't allow memory operations to cross below us in the target stack
 745    anyway.  */
 746 static int
 747 procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
 748                     struct mem_attrib *attrib, struct target_ops *target)
 749 {
 750   int nbytes = 0;
 751
 752   if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
 753     {
 754       if (dowrite)
 755         nbytes = write (ctl_fd, myaddr, len);
 756       else
 757         nbytes = read (ctl_fd, myaddr, len);
 758       if (nbytes < 0)
 759         nbytes = 0;
 760     }
 761   return (nbytes);
 762 }
 763
 764 /* Take a program previously attached to and detaches it.
 765    The program resumes execution and will no longer stop
 766    on signals, etc.  We'd better not have left any breakpoints
 767    in the program or it'll die when it hits one.  */
 768 static void
 769 procfs_detach (char *args, int from_tty)
 770 {
 771   int siggnal = 0;
 772
 773   if (from_tty)
 774     {
 775       char *exec_file = get_exec_file (0);
 776       if (exec_file == 0)
 777         exec_file = "";
 778       printf_unfiltered ("Detaching from program: %s %s\n",
 779                          exec_file, target_pid_to_str (inferior_ptid));
 780       gdb_flush (gdb_stdout);
 781     }
 782   if (args)
 783     siggnal = atoi (args);
 784
 785   if (siggnal)
 786     SignalKill (nto_node (), PIDGET (inferior_ptid), 0, siggnal, 0, 0);
 787
 788   close (ctl_fd);
 789   ctl_fd = -1;
 790   init_thread_list ();
 791   inferior_ptid = null_ptid;
 792   attach_flag = 0;
 793   unpush_target (&procfs_ops);  /* Pop out of handling an inferior.  */
 794 }
 795
 796 static int
 797 procfs_breakpoint (CORE_ADDR addr, int type, int size)
 798 {
 799   procfs_break brk;
 800
 801   brk.type = type;
 802   brk.addr = addr;
 803   brk.size = size;
 804   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
 805   if (errno != EOK)
 806     return 1;
 807   return 0;
 808 }
 809
 810 static int
 811 procfs_insert_breakpoint (struct bp_target_info *bp_tgt)
 812 {
 813   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
 814 }
 815
 816 static int
 817 procfs_remove_breakpoint (struct bp_target_info *bp_tgt)
 818 {
 819   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
 820 }
 821
 822 static int
 823 procfs_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
 824 {
 825   return procfs_breakpoint (bp_tgt->placed_address,
 826                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
 827 }
 828
 829 static int
 830 procfs_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
 831 {
 832   return procfs_breakpoint (bp_tgt->placed_address,
 833                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
 834 }
 835
 836 static void
 837 procfs_resume (ptid_t ptid, int step, enum target_signal signo)
 838 {
 839   int signal_to_pass;
 840   procfs_status status;
 841   sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
 842
 843   if (ptid_equal (inferior_ptid, null_ptid))
 844     return;
 845
 846   procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
 847                      ptid);
 848
 849   run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
 850   if (step)
 851     run.flags |= _DEBUG_RUN_STEP;
 852
 853   sigemptyset (run_fault);
 854   sigaddset (run_fault, FLTBPT);
 855   sigaddset (run_fault, FLTTRACE);
 856   sigaddset (run_fault, FLTILL);
 857   sigaddset (run_fault, FLTPRIV);
 858   sigaddset (run_fault, FLTBOUNDS);
 859   sigaddset (run_fault, FLTIOVF);
 860   sigaddset (run_fault, FLTIZDIV);
 861   sigaddset (run_fault, FLTFPE);
 862   /* Peter V will be changing this at some point.  */
 863   sigaddset (run_fault, FLTPAGE);
 864
 865   run.flags |= _DEBUG_RUN_ARM;
 866
 867   sigemptyset (&run.trace);
 868   notice_signals ();
 869   signal_to_pass = target_signal_to_host (signo);
 870
 871   if (signal_to_pass)
 872     {
 873       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 874       signal_to_pass = target_signal_to_host (signo);
 875       if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
 876         {
 877           if (signal_to_pass != status.info.si_signo)
 878             {
 879               SignalKill (nto_node (), PIDGET (inferior_ptid), 0,
 880                           signal_to_pass, 0, 0);
 881               run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
 882             }
 883           else                  /* Let it kill the program without telling us.  */
 884             sigdelset (&run.trace, signal_to_pass);
 885         }
 886     }
 887   else
 888     run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
 889
 890   errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
 891   if (errno != EOK)
 892     {
 893       perror ("run error!\n");
 894       return;
 895     }
 896 }
 897
 898 static void
 899 procfs_mourn_inferior (void)
 900 {
 901   if (!ptid_equal (inferior_ptid, null_ptid))
 902     {
 903       SignalKill (nto_node (), PIDGET (inferior_ptid), 0, SIGKILL, 0, 0);
 904       close (ctl_fd);
 905     }
 906   inferior_ptid = null_ptid;
 907   init_thread_list ();
 908   unpush_target (&procfs_ops);
 909   generic_mourn_inferior ();
 910   attach_flag = 0;
 911 }
 912
 913 /* This function breaks up an argument string into an argument
 914    vector suitable for passing to execvp().
 915    E.g., on "run a b c d" this routine would get as input
 916    the string "a b c d", and as output it would fill in argv with
 917    the four arguments "a", "b", "c", "d".  The only additional
 918    functionality is simple quoting.  The gdb command:
 919         run a "b c d" f
 920    will fill in argv with the three args "a", "b c d", "e".  */
 921 static void
 922 breakup_args (char *scratch, char **argv)
 923 {
 924   char *pp, *cp = scratch;
 925   char quoting = 0;
 926
 927   for (;;)
 928     {
 929       /* Scan past leading separators.  */
 930       quoting = 0;
 931       while (*cp == ' ' || *cp == '\t' || *cp == '\n')
 932         cp++;
 933
 934       /* Break if at end of string.  */
 935       if (*cp == '\0')
 936         break;
 937
 938       /* Take an arg.  */
 939       if (*cp == '"')
 940         {
 941           cp++;
 942           quoting = strchr (cp, '"') ? 1 : 0;
 943         }
 944
 945       *argv++ = cp;
 946
 947       /* Scan for next arg separator.  */
 948       pp = cp;
 949       if (quoting)
 950         cp = strchr (pp, '"');
 951       if ((cp == NULL) || (!quoting))
 952         cp = strchr (pp, ' ');
 953       if (cp == NULL)
 954         cp = strchr (pp, '\t');
 955       if (cp == NULL)
 956         cp = strchr (pp, '\n');
 957
 958       /* No separators => end of string => break.  */
 959       if (cp == NULL)
 960         {
 961           pp = cp;
 962           break;
 963         }
 964
 965       /* Replace the separator with a terminator.  */
 966       *cp++ = '\0';
 967     }
 968
 969   /* Execv requires a null-terminated arg vector.  */
 970   *argv = NULL;
 971 }
 972
 973 static void
 974 procfs_create_inferior (char *exec_file, char *allargs, char **env,
 975                         int from_tty)
 976 {
 977   struct inheritance inherit;
 978   pid_t pid;
 979   int flags, errn;
 980   char **argv, *args;
 981   const char *in = "", *out = "", *err = "";
 982   int fd, fds[3];
 983   sigset_t set;
 984   const char *inferior_io_terminal = get_inferior_io_terminal ();
 985
 986   argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
 987                   sizeof (*argv));
 988   argv[0] = get_exec_file (1);
 989   if (!argv[0])
 990     {
 991       if (exec_file)
 992         argv[0] = exec_file;
 993       else
 994         return;
 995     }
 996
 997   args = xstrdup (allargs);
 998   breakup_args (args, exec_file ? &argv[1] : &argv[0]);
 999
1000   argv = nto_parse_redirection (argv, &in, &out, &err);
1001
1002   fds[0] = STDIN_FILENO;
1003   fds[1] = STDOUT_FILENO;
1004   fds[2] = STDERR_FILENO;
1005
1006   /* If the user specified I/O via gdb's --tty= arg, use it, but only
1007      if the i/o is not also being specified via redirection.  */
1008   if (inferior_io_terminal)
1009     {
1010       if (!in[0])
1011         in = inferior_io_terminal;
1012       if (!out[0])
1013         out = inferior_io_terminal;
1014       if (!err[0])
1015         err = inferior_io_terminal;
1016     }
1017
1018   if (in[0])
1019     {
1020       fd = open (in, O_RDONLY);
1021       if (fd == -1)
1022         perror (in);
1023       else
1024         fds[0] = fd;
1025     }
1026   if (out[0])
1027     {
1028       fd = open (out, O_WRONLY);
1029       if (fd == -1)
1030         perror (out);
1031       else
1032         fds[1] = fd;
1033     }
1034   if (err[0])
1035     {
1036       fd = open (err, O_WRONLY);
1037       if (fd == -1)
1038         perror (err);
1039       else
1040         fds[2] = fd;
1041     }
1042
1043   /* Clear any pending SIGUSR1's but keep the behavior the same.  */
1044   signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1045
1046   sigemptyset (&set);
1047   sigaddset (&set, SIGUSR1);
1048   sigprocmask (SIG_UNBLOCK, &set, NULL);
1049
1050   memset (&inherit, 0, sizeof (inherit));
1051
1052   if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1053     {
1054       inherit.nd = nto_node ();
1055       inherit.flags |= SPAWN_SETND;
1056       inherit.flags &= ~SPAWN_EXEC;
1057     }
1058   inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1059   inherit.pgroup = SPAWN_NEWPGROUP;
1060   pid = spawnp (argv[0], 3, fds, &inherit, argv,
1061                 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1062   xfree (args);
1063
1064   sigprocmask (SIG_BLOCK, &set, NULL);
1065
1066   if (pid == -1)
1067     error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1068            safe_strerror (errno));
1069
1070   if (fds[0] != STDIN_FILENO)
1071     close (fds[0]);
1072   if (fds[1] != STDOUT_FILENO)
1073     close (fds[1]);
1074   if (fds[2] != STDERR_FILENO)
1075     close (fds[2]);
1076
1077   inferior_ptid = do_attach (pid_to_ptid (pid));
1078
1079   attach_flag = 0;
1080   flags = _DEBUG_FLAG_KLC;      /* Kill-on-Last-Close flag.  */
1081   errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1082   if (errn != EOK)
1083     {
1084       /* FIXME: expected warning?  */
1085       /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1086          errn, strerror(errn) ); */
1087     }
1088   push_target (&procfs_ops);
1089   target_terminal_init ();
1090
1091   if (exec_bfd != NULL
1092       || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1093     solib_create_inferior_hook ();
1094   stop_soon = 0;
1095 }
1096
1097 static void
1098 procfs_stop (ptid_t ptid)
1099 {
1100   devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1101 }
1102
1103 static void
1104 procfs_kill_inferior (void)
1105 {
1106   target_mourn_inferior ();
1107 }
1108
1109 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1110    of REGISTERS.  */
1111 static void
1112 procfs_prepare_to_store (struct regcache *regcache)
1113 {
1114 }
1115
1116 /* Fill buf with regset and return devctl cmd to do the setting.  Return
1117    -1 if we fail to get the regset.  Store size of regset in regsize.  */
1118 static int
1119 get_regset (int regset, char *buf, int bufsize, int *regsize)
1120 {
1121   int dev_get, dev_set;
1122   switch (regset)
1123     {
1124     case NTO_REG_GENERAL:
1125       dev_get = DCMD_PROC_GETGREG;
1126       dev_set = DCMD_PROC_SETGREG;
1127       break;
1128
1129     case NTO_REG_FLOAT:
1130       dev_get = DCMD_PROC_GETFPREG;
1131       dev_set = DCMD_PROC_SETFPREG;
1132       break;
1133
1134     case NTO_REG_ALT:
1135       dev_get = DCMD_PROC_GETALTREG;
1136       dev_set = DCMD_PROC_SETALTREG;
1137       break;
1138
1139     case NTO_REG_SYSTEM:
1140     default:
1141       return -1;
1142     }
1143   if (devctl (ctl_fd, dev_get, &buf, bufsize, regsize) != EOK)
1144     return -1;
1145
1146   return dev_set;
1147 }
1148
1149 void
1150 procfs_store_registers (struct regcache *regcache, int regno)
1151 {
1152   union
1153   {
1154     procfs_greg greg;
1155     procfs_fpreg fpreg;
1156     procfs_altreg altreg;
1157   }
1158   reg;
1159   unsigned off;
1160   int len, regset, regsize, dev_set, err;
1161   char *data;
1162
1163   if (ptid_equal (inferior_ptid, null_ptid))
1164     return;
1165   procfs_set_thread (inferior_ptid);
1166
1167   if (regno == -1)
1168     {
1169       for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1170         {
1171           dev_set = get_regset (regset, (char *) &reg,
1172                                 sizeof (reg), &regsize);
1173           if (dev_set == -1)
1174             continue;
1175
1176           if (nto_regset_fill (regcache, regset, (char *) &reg) == -1)
1177             continue;
1178
1179           err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1180           if (err != EOK)
1181             fprintf_unfiltered (gdb_stderr,
1182                                 "Warning unable to write regset %d: %s\n",
1183                                 regno, safe_strerror (err));
1184         }
1185     }
1186   else
1187     {
1188       regset = nto_regset_id (regno);
1189       if (regset == -1)
1190         return;
1191
1192       dev_set = get_regset (regset, (char *) &reg, sizeof (reg), &regsize);
1193       if (dev_set == -1)
1194         return;
1195
1196       len = nto_register_area (regno, regset, &off);
1197
1198       if (len < 1)
1199         return;
1200
1201       regcache_raw_collect (regcache, regno, (char *) &reg + off);
1202
1203       err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1204       if (err != EOK)
1205         fprintf_unfiltered (gdb_stderr,
1206                             "Warning unable to write regset %d: %s\n", regno,
1207                             safe_strerror (err));
1208     }
1209 }
1210
1211 static void
1212 notice_signals (void)
1213 {
1214   int signo;
1215
1216   for (signo = 1; signo < NSIG; signo++)
1217     {
1218       if (signal_stop_state (target_signal_from_host (signo)) == 0
1219           && signal_print_state (target_signal_from_host (signo)) == 0
1220           && signal_pass_state (target_signal_from_host (signo)) == 1)
1221         sigdelset (&run.trace, signo);
1222       else
1223         sigaddset (&run.trace, signo);
1224     }
1225 }
1226
1227 /* When the user changes the state of gdb's signal handling via the
1228    "handle" command, this function gets called to see if any change
1229    in the /proc interface is required.  It is also called internally
1230    by other /proc interface functions to initialize the state of
1231    the traced signal set.  */
1232 static void
1233 procfs_notice_signals (ptid_t ptid)
1234 {
1235   sigemptyset (&run.trace);
1236   notice_signals ();
1237 }
1238
1239 static struct tidinfo *
1240 procfs_thread_info (pid_t pid, short tid)
1241 {
1242 /* NYI */
1243   return NULL;
1244 }
1245
1246 char *
1247 procfs_pid_to_str (ptid_t ptid)
1248 {
1249   static char buf[1024];
1250   int pid, tid, n;
1251   struct tidinfo *tip;
1252
1253   pid = ptid_get_pid (ptid);
1254   tid = ptid_get_tid (ptid);
1255
1256   n = snprintf (buf, 1023, "process %d", pid);
1257
1258 #if 0                           /* NYI */
1259   tip = procfs_thread_info (pid, tid);
1260   if (tip != NULL)
1261     snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1262 #endif
1263
1264   return buf;
1265 }
1266
1267 static void
1268 init_procfs_ops (void)
1269 {
1270   procfs_ops.to_shortname = "procfs";
1271   procfs_ops.to_longname = "QNX Neutrino procfs child process";
1272   procfs_ops.to_doc =
1273     "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1274         target procfs <node>";
1275   procfs_ops.to_open = procfs_open;
1276   procfs_ops.to_attach = procfs_attach;
1277   procfs_ops.to_post_attach = procfs_post_attach;
1278   procfs_ops.to_detach = procfs_detach;
1279   procfs_ops.to_resume = procfs_resume;
1280   procfs_ops.to_wait = procfs_wait;
1281   procfs_ops.to_fetch_registers = procfs_fetch_registers;
1282   procfs_ops.to_store_registers = procfs_store_registers;
1283   procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
1284   procfs_ops.deprecated_xfer_memory = procfs_xfer_memory;
1285   procfs_ops.to_files_info = procfs_files_info;
1286   procfs_ops.to_insert_breakpoint = procfs_insert_breakpoint;
1287   procfs_ops.to_remove_breakpoint = procfs_remove_breakpoint;
1288   procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
1289   procfs_ops.to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
1290   procfs_ops.to_remove_hw_breakpoint = procfs_remove_breakpoint;
1291   procfs_ops.to_insert_watchpoint = procfs_insert_hw_watchpoint;
1292   procfs_ops.to_remove_watchpoint = procfs_remove_hw_watchpoint;
1293   procfs_ops.to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
1294   procfs_ops.to_terminal_init = terminal_init_inferior;
1295   procfs_ops.to_terminal_inferior = terminal_inferior;
1296   procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1297   procfs_ops.to_terminal_ours = terminal_ours;
1298   procfs_ops.to_terminal_info = child_terminal_info;
1299   procfs_ops.to_kill = procfs_kill_inferior;
1300   procfs_ops.to_create_inferior = procfs_create_inferior;
1301   procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
1302   procfs_ops.to_can_run = procfs_can_run;
1303   procfs_ops.to_notice_signals = procfs_notice_signals;
1304   procfs_ops.to_thread_alive = procfs_thread_alive;
1305   procfs_ops.to_find_new_threads = procfs_find_new_threads;
1306   procfs_ops.to_pid_to_str = procfs_pid_to_str;
1307   procfs_ops.to_stop = procfs_stop;
1308   procfs_ops.to_stratum = process_stratum;
1309   procfs_ops.to_has_all_memory = 1;
1310   procfs_ops.to_has_memory = 1;
1311   procfs_ops.to_has_stack = 1;
1312   procfs_ops.to_has_registers = 1;
1313   procfs_ops.to_has_execution = 1;
1314   procfs_ops.to_magic = OPS_MAGIC;
1315   procfs_ops.to_have_continuable_watchpoint = 1;
1316 }
1317
1318 #define OSTYPE_NTO 1
1319
1320 void
1321 _initialize_procfs (void)
1322 {
1323   sigset_t set;
1324
1325   init_procfs_ops ();
1326   add_target (&procfs_ops);
1327
1328   /* We use SIGUSR1 to gain control after we block waiting for a process.
1329      We use sigwaitevent to wait.  */
1330   sigemptyset (&set);
1331   sigaddset (&set, SIGUSR1);
1332   sigprocmask (SIG_BLOCK, &set, NULL);
1333
1334   /* Set up trace and fault sets, as gdb expects them.  */
1335   sigemptyset (&run.trace);
1336
1337   /* Stuff some information.  */
1338   nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1339   nto_cpuinfo_valid = 1;
1340
1341   add_info ("pidlist", procfs_pidlist, _("pidlist"));
1342   add_info ("meminfo", procfs_meminfo, _("memory information"));
1343
1344   nto_is_nto_target = procfs_is_nto_target;
1345 }
1346
1347
1348 static int
1349 procfs_hw_watchpoint (int addr, int len, int type)
1350 {
1351   procfs_break brk;
1352
1353   switch (type)
1354     {
1355     case 1:                     /* Read.  */
1356       brk.type = _DEBUG_BREAK_RD;
1357       break;
1358     case 2:                     /* Read/Write.  */
1359       brk.type = _DEBUG_BREAK_RW;
1360       break;
1361     default:                    /* Modify.  */
1362 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason.  */
1363       brk.type = _DEBUG_BREAK_RW;
1364     }
1365   brk.type |= _DEBUG_BREAK_HW;  /* Always ask for HW.  */
1366   brk.addr = addr;
1367   brk.size = len;
1368
1369   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1370   if (errno != EOK)
1371     {
1372       perror ("Failed to set hardware watchpoint");
1373       return -1;
1374     }
1375   return 0;
1376 }
1377
1378 static int
1379 procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
1380 {
1381   return 1;
1382 }
1383
1384 static int
1385 procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type)
1386 {
1387   return procfs_hw_watchpoint (addr, -1, type);
1388 }
1389
1390 static int
1391 procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type)
1392 {
1393   return procfs_hw_watchpoint (addr, len, type);
1394 }
1395
1396 static int
1397 procfs_stopped_by_watchpoint (void)
1398 {
1399   return 0;
1400 }