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 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 2 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, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  23    Boston, MA 02110-1301, USA.  */
  24
  25 #include "defs.h"
  26
  27 #include <fcntl.h>
  28 #include <spawn.h>
  29 #include <sys/debug.h>
  30 #include <sys/procfs.h>
  31 #include <sys/neutrino.h>
  32 #include <sys/syspage.h>
  33 #include "gdb_dirent.h"
  34 #include <sys/netmgr.h>
  35
  36 #include "exceptions.h"
  37 #include "gdb_string.h"
  38 #include "gdbcore.h"
  39 #include "inferior.h"
  40 #include "target.h"
  41 #include "objfiles.h"
  42 #include "gdbthread.h"
  43 #include "nto-tdep.h"
  44 #include "command.h"
  45 #include "regcache.h"
  46
  47 #define NULL_PID                0
  48 #define _DEBUG_FLAG_TRACE       (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
  49                 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
  50
  51 static struct target_ops procfs_ops;
  52
  53 int ctl_fd;
  54
  55 static void (*ofunc) ();
  56
  57 static procfs_run run;
  58
  59 static void procfs_open (char *, int);
  60
  61 static int procfs_can_run (void);
  62
  63 static ptid_t procfs_wait (ptid_t, struct target_waitstatus *);
  64
  65 static int procfs_xfer_memory (CORE_ADDR, char *, int, int,
  66                                struct mem_attrib *attrib,
  67                                struct target_ops *);
  68
  69 static void procfs_fetch_registers (int);
  70
  71 static void notice_signals (void);
  72
  73 static void init_procfs_ops (void);
  74
  75 static ptid_t do_attach (ptid_t ptid);
  76
  77 static int procfs_can_use_hw_breakpoint (int, int, int);
  78
  79 static int procfs_insert_hw_breakpoint (CORE_ADDR, char *);
  80
  81 static int procfs_remove_hw_breakpoint (CORE_ADDR addr, char *);
  82
  83 static int procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type);
  84
  85 static int procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type);
  86
  87 static int procfs_stopped_by_watchpoint (void);
  88
  89 /* These two globals are only ever set in procfs_open(), but are
  90    referenced elsewhere.  'nto_procfs_node' is a flag used to say
  91    whether we are local, or we should get the current node descriptor
  92    for the remote QNX node.  */
  93 static char nto_procfs_path[PATH_MAX] = { "/proc" };
  94 static unsigned nto_procfs_node = ND_LOCAL_NODE;
  95
  96 /* Return the current QNX Node, or error out.  This is a simple
  97    wrapper for the netmgr_strtond() function.  The reason this
  98    is required is because QNX node descriptors are transient so
  99    we have to re-acquire them every time.  */
 100 static unsigned
 101 nto_node (void)
 102 {
 103   unsigned node;
 104
 105   if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0)
 106     return ND_LOCAL_NODE;
 107
 108   node = netmgr_strtond (nto_procfs_path, 0);
 109   if (node == -1)
 110     error (_("Lost the QNX node.  Debug session probably over."));
 111
 112   return (node);
 113 }
 114
 115 static enum gdb_osabi
 116 procfs_is_nto_target (bfd *abfd)
 117 {
 118   return GDB_OSABI_QNXNTO;
 119 }
 120
 121 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
 122    For QNX6 (nto), the only valid arg will be a QNX node string,
 123    eg: "/net/some_node".  If arg is not a valid QNX node, we will
 124    default to local.  */
 125 static void
 126 procfs_open (char *arg, int from_tty)
 127 {
 128   char *nodestr;
 129   char *endstr;
 130   char buffer[50];
 131   int fd, total_size;
 132   procfs_sysinfo *sysinfo;
 133
 134   nto_is_nto_target = procfs_is_nto_target;
 135
 136   /* Set the default node used for spawning to this one,
 137      and only override it if there is a valid arg.  */
 138
 139   nto_procfs_node = ND_LOCAL_NODE;
 140   nodestr = arg ? xstrdup (arg) : arg;
 141
 142   init_thread_list ();
 143
 144   if (nodestr)
 145     {
 146       nto_procfs_node = netmgr_strtond (nodestr, &endstr);
 147       if (nto_procfs_node == -1)
 148         {
 149           if (errno == ENOTSUP)
 150             printf_filtered ("QNX Net Manager not found.\n");
 151           printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr,
 152                            errno, safe_strerror (errno));
 153           xfree (nodestr);
 154           nodestr = NULL;
 155           nto_procfs_node = ND_LOCAL_NODE;
 156         }
 157       else if (*endstr)
 158         {
 159           if (*(endstr - 1) == '/')
 160             *(endstr - 1) = 0;
 161           else
 162             *endstr = 0;
 163         }
 164     }
 165   snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "",
 166             "/proc");
 167   if (nodestr)
 168     xfree (nodestr);
 169
 170   fd = open (nto_procfs_path, O_RDONLY);
 171   if (fd == -1)
 172     {
 173       printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
 174                        safe_strerror (errno));
 175       error (_("Invalid procfs arg"));
 176     }
 177
 178   sysinfo = (void *) buffer;
 179   if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
 180     {
 181       printf_filtered ("Error getting size: %d (%s)\n", errno,
 182                        safe_strerror (errno));
 183       close (fd);
 184       error (_("Devctl failed."));
 185     }
 186   else
 187     {
 188       total_size = sysinfo->total_size;
 189       sysinfo = alloca (total_size);
 190       if (!sysinfo)
 191         {
 192           printf_filtered ("Memory error: %d (%s)\n", errno,
 193                            safe_strerror (errno));
 194           close (fd);
 195           error (_("alloca failed."));
 196         }
 197       else
 198         {
 199           if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
 200             {
 201               printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
 202                                safe_strerror (errno));
 203               close (fd);
 204               error (_("Devctl failed."));
 205             }
 206           else
 207             {
 208               if (sysinfo->type !=
 209                   nto_map_arch_to_cputype (TARGET_ARCHITECTURE->arch_name))
 210                 {
 211                   close (fd);
 212                   error (_("Invalid target CPU."));
 213                 }
 214             }
 215         }
 216     }
 217   close (fd);
 218   printf_filtered ("Debugging using %s\n", nto_procfs_path);
 219 }
 220
 221 static void
 222 procfs_set_thread (ptid_t ptid)
 223 {
 224   pid_t tid;
 225
 226   tid = ptid_get_tid (ptid);
 227   devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
 228 }
 229
 230 /*  Return nonzero if the thread TH is still alive.  */
 231 static int
 232 procfs_thread_alive (ptid_t ptid)
 233 {
 234   pid_t tid;
 235
 236   tid = ptid_get_tid (ptid);
 237   if (devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0) == EOK)
 238     return 1;
 239   return 0;
 240 }
 241
 242 void
 243 procfs_find_new_threads (void)
 244 {
 245   procfs_status status;
 246   pid_t pid;
 247   ptid_t ptid;
 248
 249   if (ctl_fd == -1)
 250     return;
 251
 252   pid = ptid_get_pid (inferior_ptid);
 253
 254   for (status.tid = 1;; ++status.tid)
 255     {
 256       if (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
 257           != EOK && status.tid != 0)
 258         break;
 259       ptid = ptid_build (pid, 0, status.tid);
 260       if (!in_thread_list (ptid))
 261         add_thread (ptid);
 262     }
 263   return;
 264 }
 265
 266 void
 267 procfs_pidlist (char *args, int from_tty)
 268 {
 269   DIR *dp = NULL;
 270   struct dirent *dirp = NULL;
 271   int fd = -1;
 272   char buf[512];
 273   procfs_info *pidinfo = NULL;
 274   procfs_debuginfo *info = NULL;
 275   procfs_status *status = NULL;
 276   pid_t num_threads = 0;
 277   pid_t pid;
 278   char name[512];
 279
 280   dp = opendir (nto_procfs_path);
 281   if (dp == NULL)
 282     {
 283       fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
 284                           nto_procfs_path, errno, safe_strerror (errno));
 285       return;
 286     }
 287
 288   /* Start scan at first pid.  */
 289   rewinddir (dp);
 290
 291   do
 292     {
 293       /* Get the right pid and procfs path for the pid.  */
 294       do
 295         {
 296           dirp = readdir (dp);
 297           if (dirp == NULL)
 298             {
 299               closedir (dp);
 300               return;
 301             }
 302           snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name);
 303           pid = atoi (dirp->d_name);
 304         }
 305       while (pid == 0);
 306
 307       /* Open the procfs path. */
 308       fd = open (buf, O_RDONLY);
 309       if (fd == -1)
 310         {
 311           fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
 312                               buf, errno, safe_strerror (errno));
 313           closedir (dp);
 314           return;
 315         }
 316
 317       pidinfo = (procfs_info *) buf;
 318       if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
 319         {
 320           fprintf_unfiltered (gdb_stderr,
 321                               "devctl DCMD_PROC_INFO failed - %d (%s)\n",
 322                               errno, safe_strerror (errno));
 323           break;
 324         }
 325       num_threads = pidinfo->num_threads;
 326
 327       info = (procfs_debuginfo *) buf;
 328       if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)
 329         strcpy (name, "unavailable");
 330       else
 331         strcpy (name, info->path);
 332
 333       /* Collect state info on all the threads.  */
 334       status = (procfs_status *) buf;
 335       for (status->tid = 1; status->tid <= num_threads; status->tid++)
 336         {
 337           if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK
 338               && status->tid != 0)
 339             break;
 340           if (status->tid != 0)
 341             printf_filtered ("%s - %d/%d\n", name, pid, status->tid);
 342         }
 343       close (fd);
 344     }
 345   while (dirp != NULL);
 346
 347   close (fd);
 348   closedir (dp);
 349   return;
 350 }
 351
 352 void
 353 procfs_meminfo (char *args, int from_tty)
 354 {
 355   procfs_mapinfo *mapinfos = NULL;
 356   static int num_mapinfos = 0;
 357   procfs_mapinfo *mapinfo_p, *mapinfo_p2;
 358   int flags = ~0, err, num, i, j;
 359
 360   struct
 361   {
 362     procfs_debuginfo info;
 363     char buff[_POSIX_PATH_MAX];
 364   } map;
 365
 366   struct info
 367   {
 368     unsigned addr;
 369     unsigned size;
 370     unsigned flags;
 371     unsigned debug_vaddr;
 372     unsigned long long offset;
 373   };
 374
 375   struct printinfo
 376   {
 377     unsigned long long ino;
 378     unsigned dev;
 379     struct info text;
 380     struct info data;
 381     char name[256];
 382   } printme;
 383
 384   /* Get the number of map entrys.  */
 385   err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
 386   if (err != EOK)
 387     {
 388       printf ("failed devctl num mapinfos - %d (%s)\n", err,
 389               safe_strerror (err));
 390       return;
 391     }
 392
 393   mapinfos = xmalloc (num * sizeof (procfs_mapinfo));
 394
 395   num_mapinfos = num;
 396   mapinfo_p = mapinfos;
 397
 398   /* Fill the map entrys.  */
 399   err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
 400                 * sizeof (procfs_mapinfo), &num);
 401   if (err != EOK)
 402     {
 403       printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
 404       xfree (mapinfos);
 405       return;
 406     }
 407
 408   num = min (num, num_mapinfos);
 409
 410   /* Run through the list of mapinfos, and store the data and text info
 411      so we can print it at the bottom of the loop.  */
 412   for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
 413     {
 414       if (!(mapinfo_p->flags & flags))
 415         mapinfo_p->ino = 0;
 416
 417       if (mapinfo_p->ino == 0)  /* Already visited.  */
 418         continue;
 419
 420       map.info.vaddr = mapinfo_p->vaddr;
 421
 422       err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
 423       if (err != EOK)
 424         continue;
 425
 426       memset (&printme, 0, sizeof printme);
 427       printme.dev = mapinfo_p->dev;
 428       printme.ino = mapinfo_p->ino;
 429       printme.text.addr = mapinfo_p->vaddr;
 430       printme.text.size = mapinfo_p->size;
 431       printme.text.flags = mapinfo_p->flags;
 432       printme.text.offset = mapinfo_p->offset;
 433       printme.text.debug_vaddr = map.info.vaddr;
 434       strcpy (printme.name, map.info.path);
 435
 436       /* Check for matching data.  */
 437       for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
 438         {
 439           if (mapinfo_p2->vaddr != mapinfo_p->vaddr
 440               && mapinfo_p2->ino == mapinfo_p->ino
 441               && mapinfo_p2->dev == mapinfo_p->dev)
 442             {
 443               map.info.vaddr = mapinfo_p2->vaddr;
 444               err =
 445                 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
 446               if (err != EOK)
 447                 continue;
 448
 449               if (strcmp (map.info.path, printme.name))
 450                 continue;
 451
 452               /* Lower debug_vaddr is always text, if nessessary, swap.  */
 453               if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
 454                 {
 455                   memcpy (&(printme.data), &(printme.text),
 456                           sizeof (printme.data));
 457                   printme.text.addr = mapinfo_p2->vaddr;
 458                   printme.text.size = mapinfo_p2->size;
 459                   printme.text.flags = mapinfo_p2->flags;
 460                   printme.text.offset = mapinfo_p2->offset;
 461                   printme.text.debug_vaddr = map.info.vaddr;
 462                 }
 463               else
 464                 {
 465                   printme.data.addr = mapinfo_p2->vaddr;
 466                   printme.data.size = mapinfo_p2->size;
 467                   printme.data.flags = mapinfo_p2->flags;
 468                   printme.data.offset = mapinfo_p2->offset;
 469                   printme.data.debug_vaddr = map.info.vaddr;
 470                 }
 471               mapinfo_p2->ino = 0;
 472             }
 473         }
 474       mapinfo_p->ino = 0;
 475
 476       printf_filtered ("%s\n", printme.name);
 477       printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
 478                        printme.text.addr);
 479       printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
 480       printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
 481       printf_filtered ("\t\toffset=%016llx\n", printme.text.offset);
 482       if (printme.data.size)
 483         {
 484           printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
 485                            printme.data.addr);
 486           printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
 487           printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
 488           printf_filtered ("\t\toffset=%016llx\n", printme.data.offset);
 489         }
 490       printf_filtered ("\tdev=0x%x\n", printme.dev);
 491       printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
 492     }
 493   xfree (mapinfos);
 494   return;
 495 }
 496
 497 /* Print status information about what we're accessing.  */
 498 static void
 499 procfs_files_info (struct target_ops *ignore)
 500 {
 501   printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
 502                      attach_flag ? "attached" : "child",
 503                      target_pid_to_str (inferior_ptid), nto_procfs_path);
 504 }
 505
 506 /* Mark our target-struct as eligible for stray "run" and "attach" commands.  */
 507 static int
 508 procfs_can_run (void)
 509 {
 510   return 1;
 511 }
 512
 513 /* Attach to process PID, then initialize for debugging it.  */
 514 static void
 515 procfs_attach (char *args, int from_tty)
 516 {
 517   char *exec_file;
 518   int pid;
 519
 520   if (!args)
 521     error_no_arg (_("process-id to attach"));
 522
 523   pid = atoi (args);
 524
 525   if (pid == getpid ())
 526     error (_("Attaching GDB to itself is not a good idea..."));
 527
 528   if (from_tty)
 529     {
 530       exec_file = (char *) get_exec_file (0);
 531
 532       if (exec_file)
 533         printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
 534                            target_pid_to_str (pid_to_ptid (pid)));
 535       else
 536         printf_unfiltered ("Attaching to %s\n",
 537                            target_pid_to_str (pid_to_ptid (pid)));
 538
 539       gdb_flush (gdb_stdout);
 540     }
 541   inferior_ptid = do_attach (pid_to_ptid (pid));
 542   push_target (&procfs_ops);
 543 }
 544
 545 static void
 546 procfs_post_attach (pid_t pid)
 547 {
 548   if (exec_bfd)
 549     solib_create_inferior_hook ();
 550 }
 551
 552 static ptid_t
 553 do_attach (ptid_t ptid)
 554 {
 555   procfs_status status;
 556   struct sigevent event;
 557   char path[PATH_MAX];
 558
 559   snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path, PIDGET (ptid));
 560   ctl_fd = open (path, O_RDWR);
 561   if (ctl_fd == -1)
 562     error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
 563            safe_strerror (errno));
 564   if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
 565     error (_("Couldn't stop process"));
 566
 567   /* Define a sigevent for process stopped notification.  */
 568   event.sigev_notify = SIGEV_SIGNAL_THREAD;
 569   event.sigev_signo = SIGUSR1;
 570   event.sigev_code = 0;
 571   event.sigev_value.sival_ptr = NULL;
 572   event.sigev_priority = -1;
 573   devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
 574
 575   if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
 576       && status.flags & _DEBUG_FLAG_STOPPED)
 577     SignalKill (nto_node (), PIDGET (ptid), 0, SIGCONT, 0, 0);
 578   attach_flag = 1;
 579   nto_init_solib_absolute_prefix ();
 580   return ptid;
 581 }
 582
 583 /* Ask the user what to do when an interrupt is received.  */
 584 static void
 585 interrupt_query (void)
 586 {
 587   target_terminal_ours ();
 588
 589   if (query ("Interrupted while waiting for the program.\n\
 590 Give up (and stop debugging it)? "))
 591     {
 592       target_mourn_inferior ();
 593       deprecated_throw_reason (RETURN_QUIT);
 594     }
 595
 596   target_terminal_inferior ();
 597 }
 598
 599 /* The user typed ^C twice.  */
 600 static void
 601 nto_interrupt_twice (int signo)
 602 {
 603   signal (signo, ofunc);
 604   interrupt_query ();
 605   signal (signo, nto_interrupt_twice);
 606 }
 607
 608 static void
 609 nto_interrupt (int signo)
 610 {
 611   /* If this doesn't work, try more severe steps.  */
 612   signal (signo, nto_interrupt_twice);
 613
 614   target_stop ();
 615 }
 616
 617 static ptid_t
 618 procfs_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 619 {
 620   sigset_t set;
 621   siginfo_t info;
 622   procfs_status status;
 623   static int exit_signo = 0;    /* To track signals that cause termination.  */
 624
 625   ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 626
 627   if (ptid_equal (inferior_ptid, null_ptid))
 628     {
 629       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 630       ourstatus->value.sig = TARGET_SIGNAL_0;
 631       exit_signo = 0;
 632       return null_ptid;
 633     }
 634
 635   sigemptyset (&set);
 636   sigaddset (&set, SIGUSR1);
 637
 638   devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 639   while (!(status.flags & _DEBUG_FLAG_ISTOP))
 640     {
 641       ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
 642       sigwaitinfo (&set, &info);
 643       signal (SIGINT, ofunc);
 644       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 645     }
 646
 647   if (status.flags & _DEBUG_FLAG_SSTEP)
 648     {
 649       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 650       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 651     }
 652   /* Was it a breakpoint?  */
 653   else if (status.flags & _DEBUG_FLAG_TRACE)
 654     {
 655       ourstatus->kind = TARGET_WAITKIND_STOPPED;
 656       ourstatus->value.sig = TARGET_SIGNAL_TRAP;
 657     }
 658   else if (status.flags & _DEBUG_FLAG_ISTOP)
 659     {
 660       switch (status.why)
 661         {
 662         case _DEBUG_WHY_SIGNALLED:
 663           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 664           ourstatus->value.sig =
 665             target_signal_from_host (status.info.si_signo);
 666           exit_signo = 0;
 667           break;
 668         case _DEBUG_WHY_FAULTED:
 669           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 670           if (status.info.si_signo == SIGTRAP)
 671             {
 672               ourstatus->value.sig = 0;
 673               exit_signo = 0;
 674             }
 675           else
 676             {
 677               ourstatus->value.sig =
 678                 target_signal_from_host (status.info.si_signo);
 679               exit_signo = ourstatus->value.sig;
 680             }
 681           break;
 682
 683         case _DEBUG_WHY_TERMINATED:
 684           {
 685             int waitval = 0;
 686
 687             waitpid (PIDGET (inferior_ptid), &waitval, WNOHANG);
 688             if (exit_signo)
 689               {
 690                 /* Abnormal death.  */
 691                 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 692                 ourstatus->value.sig = exit_signo;
 693               }
 694             else
 695               {
 696                 /* Normal death.  */
 697                 ourstatus->kind = TARGET_WAITKIND_EXITED;
 698                 ourstatus->value.integer = WEXITSTATUS (waitval);
 699               }
 700             exit_signo = 0;
 701             break;
 702           }
 703
 704         case _DEBUG_WHY_REQUESTED:
 705           /* We are assuming a requested stop is due to a SIGINT.  */
 706           ourstatus->kind = TARGET_WAITKIND_STOPPED;
 707           ourstatus->value.sig = TARGET_SIGNAL_INT;
 708           exit_signo = 0;
 709           break;
 710         }
 711     }
 712
 713   return inferior_ptid;
 714 }
 715
 716 /* Read the current values of the inferior's registers, both the
 717    general register set and floating point registers (if supported)
 718    and update gdb's idea of their current values.  */
 719 static void
 720 procfs_fetch_registers (int regno)
 721 {
 722   union
 723   {
 724     procfs_greg greg;
 725     procfs_fpreg fpreg;
 726     procfs_altreg altreg;
 727   }
 728   reg;
 729   int regsize;
 730
 731   procfs_set_thread (inferior_ptid);
 732   if (devctl (ctl_fd, DCMD_PROC_GETGREG, &reg, sizeof (reg), &regsize) == EOK)
 733     nto_supply_gregset ((char *) &reg.greg);
 734   if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
 735       == EOK)
 736     nto_supply_fpregset ((char *) &reg.fpreg);
 737   if (devctl (ctl_fd, DCMD_PROC_GETALTREG, &reg, sizeof (reg), &regsize)
 738       == EOK)
 739     nto_supply_altregset ((char *) &reg.altreg);
 740 }
 741
 742 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
 743    from/to debugger memory starting at MYADDR.  Copy from inferior
 744    if DOWRITE is zero or to inferior if DOWRITE is nonzero.
 745
 746    Returns the length copied, which is either the LEN argument or
 747    zero.  This xfer function does not do partial moves, since procfs_ops
 748    doesn't allow memory operations to cross below us in the target stack
 749    anyway.  */
 750 static int
 751 procfs_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int dowrite,
 752                     struct mem_attrib *attrib, struct target_ops *target)
 753 {
 754   int nbytes = 0;
 755
 756   if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
 757     {
 758       if (dowrite)
 759         nbytes = write (ctl_fd, myaddr, len);
 760       else
 761         nbytes = read (ctl_fd, myaddr, len);
 762       if (nbytes < 0)
 763         nbytes = 0;
 764     }
 765   return (nbytes);
 766 }
 767
 768 /* Take a program previously attached to and detaches it.
 769    The program resumes execution and will no longer stop
 770    on signals, etc.  We'd better not have left any breakpoints
 771    in the program or it'll die when it hits one.  */
 772 static void
 773 procfs_detach (char *args, int from_tty)
 774 {
 775   int siggnal = 0;
 776
 777   if (from_tty)
 778     {
 779       char *exec_file = get_exec_file (0);
 780       if (exec_file == 0)
 781         exec_file = "";
 782       printf_unfiltered ("Detaching from program: %s %s\n",
 783                          exec_file, target_pid_to_str (inferior_ptid));
 784       gdb_flush (gdb_stdout);
 785     }
 786   if (args)
 787     siggnal = atoi (args);
 788
 789   if (siggnal)
 790     SignalKill (nto_node (), PIDGET (inferior_ptid), 0, siggnal, 0, 0);
 791
 792   close (ctl_fd);
 793   ctl_fd = -1;
 794   init_thread_list ();
 795   inferior_ptid = null_ptid;
 796   attach_flag = 0;
 797   unpush_target (&procfs_ops);  /* Pop out of handling an inferior.  */
 798 }
 799
 800 static int
 801 procfs_breakpoint (CORE_ADDR addr, int type, int size)
 802 {
 803   procfs_break brk;
 804
 805   brk.type = type;
 806   brk.addr = addr;
 807   brk.size = size;
 808   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
 809   if (errno != EOK)
 810     return 1;
 811   return 0;
 812 }
 813
 814 static int
 815 procfs_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
 816 {
 817   return procfs_breakpoint (addr, _DEBUG_BREAK_EXEC, 0);
 818 }
 819
 820 static int
 821 procfs_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
 822 {
 823   return procfs_breakpoint (addr, _DEBUG_BREAK_EXEC, -1);
 824 }
 825
 826 static int
 827 procfs_insert_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
 828 {
 829   return procfs_breakpoint (addr, _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
 830 }
 831
 832 static int
 833 procfs_remove_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
 834 {
 835   return procfs_breakpoint (addr, _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
 836 }
 837
 838 static void
 839 procfs_resume (ptid_t ptid, int step, enum target_signal signo)
 840 {
 841   int signal_to_pass;
 842   procfs_status status;
 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 ((sigset_t *) &run.fault);
 855   sigaddset ((sigset_t *) &run.fault, FLTBPT);
 856   sigaddset ((sigset_t *) &run.fault, FLTTRACE);
 857   sigaddset ((sigset_t *) &run.fault, FLTILL);
 858   sigaddset ((sigset_t *) &run.fault, FLTPRIV);
 859   sigaddset ((sigset_t *) &run.fault, FLTBOUNDS);
 860   sigaddset ((sigset_t *) &run.fault, FLTIOVF);
 861   sigaddset ((sigset_t *) &run.fault, FLTIZDIV);
 862   sigaddset ((sigset_t *) &run.fault, FLTFPE);
 863   /* Peter V will be changing this at some point.  */
 864   sigaddset ((sigset_t *) &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   proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
1097 }
1098
1099 static void
1100 procfs_stop (void)
1101 {
1102   devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1103 }
1104
1105 static void
1106 procfs_kill_inferior (void)
1107 {
1108   target_mourn_inferior ();
1109 }
1110
1111 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1112    of REGISTERS.  */
1113 static void
1114 procfs_prepare_to_store (void)
1115 {
1116 }
1117
1118 /* Fill buf with regset and return devctl cmd to do the setting.  Return
1119    -1 if we fail to get the regset.  Store size of regset in regsize.  */
1120 static int
1121 get_regset (int regset, char *buf, int bufsize, int *regsize)
1122 {
1123   int dev_get, dev_set;
1124   switch (regset)
1125     {
1126     case NTO_REG_GENERAL:
1127       dev_get = DCMD_PROC_GETGREG;
1128       dev_set = DCMD_PROC_SETGREG;
1129       break;
1130
1131     case NTO_REG_FLOAT:
1132       dev_get = DCMD_PROC_GETFPREG;
1133       dev_set = DCMD_PROC_SETFPREG;
1134       break;
1135
1136     case NTO_REG_ALT:
1137       dev_get = DCMD_PROC_GETALTREG;
1138       dev_set = DCMD_PROC_SETALTREG;
1139       break;
1140
1141     case NTO_REG_SYSTEM:
1142     default:
1143       return -1;
1144     }
1145   if (devctl (ctl_fd, dev_get, &buf, bufsize, regsize) != EOK)
1146     return -1;
1147
1148   return dev_set;
1149 }
1150
1151 void
1152 procfs_store_registers (int regno)
1153 {
1154   union
1155   {
1156     procfs_greg greg;
1157     procfs_fpreg fpreg;
1158     procfs_altreg altreg;
1159   }
1160   reg;
1161   unsigned off;
1162   int len, regset, regsize, dev_set, err;
1163   char *data;
1164
1165   if (ptid_equal (inferior_ptid, null_ptid))
1166     return;
1167   procfs_set_thread (inferior_ptid);
1168
1169   if (regno == -1)
1170     {
1171       for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1172         {
1173           dev_set = get_regset (regset, (char *) &reg,
1174                                 sizeof (reg), &regsize);
1175           if (dev_set == -1)
1176             continue;
1177
1178           if (nto_regset_fill (regset, (char *) &reg) == -1)
1179             continue;
1180
1181           err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1182           if (err != EOK)
1183             fprintf_unfiltered (gdb_stderr,
1184                                 "Warning unable to write regset %d: %s\n",
1185                                 regno, safe_strerror (err));
1186         }
1187     }
1188   else
1189     {
1190       regset = nto_regset_id (regno);
1191       if (regset == -1)
1192         return;
1193
1194       dev_set = get_regset (regset, (char *) &reg, sizeof (reg), &regsize);
1195       if (dev_set == -1)
1196         return;
1197
1198       len = nto_register_area (regno, regset, &off);
1199
1200       if (len < 1)
1201         return;
1202
1203       regcache_raw_collect (current_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 }