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