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   add_inferior (pid);
 539
 540   push_target (&procfs_ops);
 541
 542   procfs_find_new_threads ();
 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 (inferior_ptid);
 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 ptid_build (status.pid, 0, status.tid);
 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 (struct regcache *regcache, 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 (regcache, (char *) &reg.greg);
 734   if (devctl (ctl_fd, DCMD_PROC_GETFPREG, &reg, sizeof (reg), &regsize)
 735       == EOK)
 736     nto_supply_fpregset (regcache, (char *) &reg.fpreg);
 737   if (devctl (ctl_fd, DCMD_PROC_GETALTREG, &reg, sizeof (reg), &regsize)
 738       == EOK)
 739     nto_supply_altregset (regcache, (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, gdb_byte *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   int pid;
 777
 778   if (from_tty)
 779     {
 780       char *exec_file = get_exec_file (0);
 781       if (exec_file == 0)
 782         exec_file = "";
 783       printf_unfiltered ("Detaching from program: %s %s\n",
 784                          exec_file, target_pid_to_str (inferior_ptid));
 785       gdb_flush (gdb_stdout);
 786     }
 787   if (args)
 788     siggnal = atoi (args);
 789
 790   if (siggnal)
 791     SignalKill (nto_node (), PIDGET (inferior_ptid), 0, siggnal, 0, 0);
 792
 793   close (ctl_fd);
 794   ctl_fd = -1;
 795
 796   pid = ptid_get_pid (inferior_ptid);
 797   inferior_ptid = null_ptid;
 798   attach_flag = 0;
 799   detach_inferior (pid);
 800   init_thread_list ();
 801   unpush_target (&procfs_ops);  /* Pop out of handling an inferior.  */
 802 }
 803
 804 static int
 805 procfs_breakpoint (CORE_ADDR addr, int type, int size)
 806 {
 807   procfs_break brk;
 808
 809   brk.type = type;
 810   brk.addr = addr;
 811   brk.size = size;
 812   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
 813   if (errno != EOK)
 814     return 1;
 815   return 0;
 816 }
 817
 818 static int
 819 procfs_insert_breakpoint (struct bp_target_info *bp_tgt)
 820 {
 821   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
 822 }
 823
 824 static int
 825 procfs_remove_breakpoint (struct bp_target_info *bp_tgt)
 826 {
 827   return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
 828 }
 829
 830 static int
 831 procfs_insert_hw_breakpoint (struct bp_target_info *bp_tgt)
 832 {
 833   return procfs_breakpoint (bp_tgt->placed_address,
 834                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
 835 }
 836
 837 static int
 838 procfs_remove_hw_breakpoint (struct bp_target_info *bp_tgt)
 839 {
 840   return procfs_breakpoint (bp_tgt->placed_address,
 841                             _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
 842 }
 843
 844 static void
 845 procfs_resume (ptid_t ptid, int step, enum target_signal signo)
 846 {
 847   int signal_to_pass;
 848   procfs_status status;
 849   sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
 850
 851   if (ptid_equal (inferior_ptid, null_ptid))
 852     return;
 853
 854   procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
 855                      ptid);
 856
 857   run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
 858   if (step)
 859     run.flags |= _DEBUG_RUN_STEP;
 860
 861   sigemptyset (run_fault);
 862   sigaddset (run_fault, FLTBPT);
 863   sigaddset (run_fault, FLTTRACE);
 864   sigaddset (run_fault, FLTILL);
 865   sigaddset (run_fault, FLTPRIV);
 866   sigaddset (run_fault, FLTBOUNDS);
 867   sigaddset (run_fault, FLTIOVF);
 868   sigaddset (run_fault, FLTIZDIV);
 869   sigaddset (run_fault, FLTFPE);
 870   /* Peter V will be changing this at some point.  */
 871   sigaddset (run_fault, FLTPAGE);
 872
 873   run.flags |= _DEBUG_RUN_ARM;
 874
 875   sigemptyset (&run.trace);
 876   notice_signals ();
 877   signal_to_pass = target_signal_to_host (signo);
 878
 879   if (signal_to_pass)
 880     {
 881       devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
 882       signal_to_pass = target_signal_to_host (signo);
 883       if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
 884         {
 885           if (signal_to_pass != status.info.si_signo)
 886             {
 887               SignalKill (nto_node (), PIDGET (inferior_ptid), 0,
 888                           signal_to_pass, 0, 0);
 889               run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
 890             }
 891           else                  /* Let it kill the program without telling us.  */
 892             sigdelset (&run.trace, signal_to_pass);
 893         }
 894     }
 895   else
 896     run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
 897
 898   errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
 899   if (errno != EOK)
 900     {
 901       perror ("run error!\n");
 902       return;
 903     }
 904 }
 905
 906 static void
 907 procfs_mourn_inferior (void)
 908 {
 909   if (!ptid_equal (inferior_ptid, null_ptid))
 910     {
 911       SignalKill (nto_node (), PIDGET (inferior_ptid), 0, SIGKILL, 0, 0);
 912       close (ctl_fd);
 913     }
 914   inferior_ptid = null_ptid;
 915   init_thread_list ();
 916   unpush_target (&procfs_ops);
 917   generic_mourn_inferior ();
 918   attach_flag = 0;
 919 }
 920
 921 /* This function breaks up an argument string into an argument
 922    vector suitable for passing to execvp().
 923    E.g., on "run a b c d" this routine would get as input
 924    the string "a b c d", and as output it would fill in argv with
 925    the four arguments "a", "b", "c", "d".  The only additional
 926    functionality is simple quoting.  The gdb command:
 927         run a "b c d" f
 928    will fill in argv with the three args "a", "b c d", "e".  */
 929 static void
 930 breakup_args (char *scratch, char **argv)
 931 {
 932   char *pp, *cp = scratch;
 933   char quoting = 0;
 934
 935   for (;;)
 936     {
 937       /* Scan past leading separators.  */
 938       quoting = 0;
 939       while (*cp == ' ' || *cp == '\t' || *cp == '\n')
 940         cp++;
 941
 942       /* Break if at end of string.  */
 943       if (*cp == '\0')
 944         break;
 945
 946       /* Take an arg.  */
 947       if (*cp == '"')
 948         {
 949           cp++;
 950           quoting = strchr (cp, '"') ? 1 : 0;
 951         }
 952
 953       *argv++ = cp;
 954
 955       /* Scan for next arg separator.  */
 956       pp = cp;
 957       if (quoting)
 958         cp = strchr (pp, '"');
 959       if ((cp == NULL) || (!quoting))
 960         cp = strchr (pp, ' ');
 961       if (cp == NULL)
 962         cp = strchr (pp, '\t');
 963       if (cp == NULL)
 964         cp = strchr (pp, '\n');
 965
 966       /* No separators => end of string => break.  */
 967       if (cp == NULL)
 968         {
 969           pp = cp;
 970           break;
 971         }
 972
 973       /* Replace the separator with a terminator.  */
 974       *cp++ = '\0';
 975     }
 976
 977   /* Execv requires a null-terminated arg vector.  */
 978   *argv = NULL;
 979 }
 980
 981 static void
 982 procfs_create_inferior (char *exec_file, char *allargs, char **env,
 983                         int from_tty)
 984 {
 985   struct inheritance inherit;
 986   pid_t pid;
 987   int flags, errn;
 988   char **argv, *args;
 989   const char *in = "", *out = "", *err = "";
 990   int fd, fds[3];
 991   sigset_t set;
 992   const char *inferior_io_terminal = get_inferior_io_terminal ();
 993
 994   argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
 995                   sizeof (*argv));
 996   argv[0] = get_exec_file (1);
 997   if (!argv[0])
 998     {
 999       if (exec_file)
1000         argv[0] = exec_file;
1001       else
1002         return;
1003     }
1004
1005   args = xstrdup (allargs);
1006   breakup_args (args, exec_file ? &argv[1] : &argv[0]);
1007
1008   argv = nto_parse_redirection (argv, &in, &out, &err);
1009
1010   fds[0] = STDIN_FILENO;
1011   fds[1] = STDOUT_FILENO;
1012   fds[2] = STDERR_FILENO;
1013
1014   /* If the user specified I/O via gdb's --tty= arg, use it, but only
1015      if the i/o is not also being specified via redirection.  */
1016   if (inferior_io_terminal)
1017     {
1018       if (!in[0])
1019         in = inferior_io_terminal;
1020       if (!out[0])
1021         out = inferior_io_terminal;
1022       if (!err[0])
1023         err = inferior_io_terminal;
1024     }
1025
1026   if (in[0])
1027     {
1028       fd = open (in, O_RDONLY);
1029       if (fd == -1)
1030         perror (in);
1031       else
1032         fds[0] = fd;
1033     }
1034   if (out[0])
1035     {
1036       fd = open (out, O_WRONLY);
1037       if (fd == -1)
1038         perror (out);
1039       else
1040         fds[1] = fd;
1041     }
1042   if (err[0])
1043     {
1044       fd = open (err, O_WRONLY);
1045       if (fd == -1)
1046         perror (err);
1047       else
1048         fds[2] = fd;
1049     }
1050
1051   /* Clear any pending SIGUSR1's but keep the behavior the same.  */
1052   signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1053
1054   sigemptyset (&set);
1055   sigaddset (&set, SIGUSR1);
1056   sigprocmask (SIG_UNBLOCK, &set, NULL);
1057
1058   memset (&inherit, 0, sizeof (inherit));
1059
1060   if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1061     {
1062       inherit.nd = nto_node ();
1063       inherit.flags |= SPAWN_SETND;
1064       inherit.flags &= ~SPAWN_EXEC;
1065     }
1066   inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1067   inherit.pgroup = SPAWN_NEWPGROUP;
1068   pid = spawnp (argv[0], 3, fds, &inherit, argv,
1069                 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1070   xfree (args);
1071
1072   sigprocmask (SIG_BLOCK, &set, NULL);
1073
1074   if (pid == -1)
1075     error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1076            safe_strerror (errno));
1077
1078   if (fds[0] != STDIN_FILENO)
1079     close (fds[0]);
1080   if (fds[1] != STDOUT_FILENO)
1081     close (fds[1]);
1082   if (fds[2] != STDERR_FILENO)
1083     close (fds[2]);
1084
1085   inferior_ptid = do_attach (pid_to_ptid (pid));
1086
1087   add_inferior (pid);
1088   attach_flag = 0;
1089
1090   flags = _DEBUG_FLAG_KLC;      /* Kill-on-Last-Close flag.  */
1091   errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1092   if (errn != EOK)
1093     {
1094       /* FIXME: expected warning?  */
1095       /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1096          errn, strerror(errn) ); */
1097     }
1098   push_target (&procfs_ops);
1099   target_terminal_init ();
1100
1101   if (exec_bfd != NULL
1102       || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1103     solib_create_inferior_hook ();
1104 }
1105
1106 static void
1107 procfs_stop (ptid_t ptid)
1108 {
1109   devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1110 }
1111
1112 static void
1113 procfs_kill_inferior (void)
1114 {
1115   target_mourn_inferior ();
1116 }
1117
1118 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1119    of REGISTERS.  */
1120 static void
1121 procfs_prepare_to_store (struct regcache *regcache)
1122 {
1123 }
1124
1125 /* Fill buf with regset and return devctl cmd to do the setting.  Return
1126    -1 if we fail to get the regset.  Store size of regset in regsize.  */
1127 static int
1128 get_regset (int regset, char *buf, int bufsize, int *regsize)
1129 {
1130   int dev_get, dev_set;
1131   switch (regset)
1132     {
1133     case NTO_REG_GENERAL:
1134       dev_get = DCMD_PROC_GETGREG;
1135       dev_set = DCMD_PROC_SETGREG;
1136       break;
1137
1138     case NTO_REG_FLOAT:
1139       dev_get = DCMD_PROC_GETFPREG;
1140       dev_set = DCMD_PROC_SETFPREG;
1141       break;
1142
1143     case NTO_REG_ALT:
1144       dev_get = DCMD_PROC_GETALTREG;
1145       dev_set = DCMD_PROC_SETALTREG;
1146       break;
1147
1148     case NTO_REG_SYSTEM:
1149     default:
1150       return -1;
1151     }
1152   if (devctl (ctl_fd, dev_get, &buf, bufsize, regsize) != EOK)
1153     return -1;
1154
1155   return dev_set;
1156 }
1157
1158 void
1159 procfs_store_registers (struct regcache *regcache, int regno)
1160 {
1161   union
1162   {
1163     procfs_greg greg;
1164     procfs_fpreg fpreg;
1165     procfs_altreg altreg;
1166   }
1167   reg;
1168   unsigned off;
1169   int len, regset, regsize, dev_set, err;
1170   char *data;
1171
1172   if (ptid_equal (inferior_ptid, null_ptid))
1173     return;
1174   procfs_set_thread (inferior_ptid);
1175
1176   if (regno == -1)
1177     {
1178       for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1179         {
1180           dev_set = get_regset (regset, (char *) &reg,
1181                                 sizeof (reg), &regsize);
1182           if (dev_set == -1)
1183             continue;
1184
1185           if (nto_regset_fill (regcache, regset, (char *) &reg) == -1)
1186             continue;
1187
1188           err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1189           if (err != EOK)
1190             fprintf_unfiltered (gdb_stderr,
1191                                 "Warning unable to write regset %d: %s\n",
1192                                 regno, safe_strerror (err));
1193         }
1194     }
1195   else
1196     {
1197       regset = nto_regset_id (regno);
1198       if (regset == -1)
1199         return;
1200
1201       dev_set = get_regset (regset, (char *) &reg, sizeof (reg), &regsize);
1202       if (dev_set == -1)
1203         return;
1204
1205       len = nto_register_area (get_regcache_arch (regcache),
1206                                regno, regset, &off);
1207
1208       if (len < 1)
1209         return;
1210
1211       regcache_raw_collect (regcache, regno, (char *) &reg + off);
1212
1213       err = devctl (ctl_fd, dev_set, &reg, regsize, 0);
1214       if (err != EOK)
1215         fprintf_unfiltered (gdb_stderr,
1216                             "Warning unable to write regset %d: %s\n", regno,
1217                             safe_strerror (err));
1218     }
1219 }
1220
1221 static void
1222 notice_signals (void)
1223 {
1224   int signo;
1225
1226   for (signo = 1; signo < NSIG; signo++)
1227     {
1228       if (signal_stop_state (target_signal_from_host (signo)) == 0
1229           && signal_print_state (target_signal_from_host (signo)) == 0
1230           && signal_pass_state (target_signal_from_host (signo)) == 1)
1231         sigdelset (&run.trace, signo);
1232       else
1233         sigaddset (&run.trace, signo);
1234     }
1235 }
1236
1237 /* When the user changes the state of gdb's signal handling via the
1238    "handle" command, this function gets called to see if any change
1239    in the /proc interface is required.  It is also called internally
1240    by other /proc interface functions to initialize the state of
1241    the traced signal set.  */
1242 static void
1243 procfs_notice_signals (ptid_t ptid)
1244 {
1245   sigemptyset (&run.trace);
1246   notice_signals ();
1247 }
1248
1249 static struct tidinfo *
1250 procfs_thread_info (pid_t pid, short tid)
1251 {
1252 /* NYI */
1253   return NULL;
1254 }
1255
1256 char *
1257 procfs_pid_to_str (ptid_t ptid)
1258 {
1259   static char buf[1024];
1260   int pid, tid, n;
1261   struct tidinfo *tip;
1262
1263   pid = ptid_get_pid (ptid);
1264   tid = ptid_get_tid (ptid);
1265
1266   n = snprintf (buf, 1023, "process %d", pid);
1267
1268 #if 0                           /* NYI */
1269   tip = procfs_thread_info (pid, tid);
1270   if (tip != NULL)
1271     snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1272 #endif
1273
1274   return buf;
1275 }
1276
1277 static void
1278 init_procfs_ops (void)
1279 {
1280   procfs_ops.to_shortname = "procfs";
1281   procfs_ops.to_longname = "QNX Neutrino procfs child process";
1282   procfs_ops.to_doc =
1283     "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1284         target procfs <node>";
1285   procfs_ops.to_open = procfs_open;
1286   procfs_ops.to_attach = procfs_attach;
1287   procfs_ops.to_post_attach = procfs_post_attach;
1288   procfs_ops.to_detach = procfs_detach;
1289   procfs_ops.to_resume = procfs_resume;
1290   procfs_ops.to_wait = procfs_wait;
1291   procfs_ops.to_fetch_registers = procfs_fetch_registers;
1292   procfs_ops.to_store_registers = procfs_store_registers;
1293   procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
1294   procfs_ops.deprecated_xfer_memory = procfs_xfer_memory;
1295   procfs_ops.to_files_info = procfs_files_info;
1296   procfs_ops.to_insert_breakpoint = procfs_insert_breakpoint;
1297   procfs_ops.to_remove_breakpoint = procfs_remove_breakpoint;
1298   procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
1299   procfs_ops.to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
1300   procfs_ops.to_remove_hw_breakpoint = procfs_remove_breakpoint;
1301   procfs_ops.to_insert_watchpoint = procfs_insert_hw_watchpoint;
1302   procfs_ops.to_remove_watchpoint = procfs_remove_hw_watchpoint;
1303   procfs_ops.to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
1304   procfs_ops.to_terminal_init = terminal_init_inferior;
1305   procfs_ops.to_terminal_inferior = terminal_inferior;
1306   procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1307   procfs_ops.to_terminal_ours = terminal_ours;
1308   procfs_ops.to_terminal_info = child_terminal_info;
1309   procfs_ops.to_kill = procfs_kill_inferior;
1310   procfs_ops.to_create_inferior = procfs_create_inferior;
1311   procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
1312   procfs_ops.to_can_run = procfs_can_run;
1313   procfs_ops.to_notice_signals = procfs_notice_signals;
1314   procfs_ops.to_thread_alive = procfs_thread_alive;
1315   procfs_ops.to_find_new_threads = procfs_find_new_threads;
1316   procfs_ops.to_pid_to_str = procfs_pid_to_str;
1317   procfs_ops.to_stop = procfs_stop;
1318   procfs_ops.to_stratum = process_stratum;
1319   procfs_ops.to_has_all_memory = 1;
1320   procfs_ops.to_has_memory = 1;
1321   procfs_ops.to_has_stack = 1;
1322   procfs_ops.to_has_registers = 1;
1323   procfs_ops.to_has_execution = 1;
1324   procfs_ops.to_magic = OPS_MAGIC;
1325   procfs_ops.to_have_continuable_watchpoint = 1;
1326 }
1327
1328 #define OSTYPE_NTO 1
1329
1330 void
1331 _initialize_procfs (void)
1332 {
1333   sigset_t set;
1334
1335   init_procfs_ops ();
1336   add_target (&procfs_ops);
1337
1338   /* We use SIGUSR1 to gain control after we block waiting for a process.
1339      We use sigwaitevent to wait.  */
1340   sigemptyset (&set);
1341   sigaddset (&set, SIGUSR1);
1342   sigprocmask (SIG_BLOCK, &set, NULL);
1343
1344   /* Set up trace and fault sets, as gdb expects them.  */
1345   sigemptyset (&run.trace);
1346
1347   /* Stuff some information.  */
1348   nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1349   nto_cpuinfo_valid = 1;
1350
1351   add_info ("pidlist", procfs_pidlist, _("pidlist"));
1352   add_info ("meminfo", procfs_meminfo, _("memory information"));
1353
1354   nto_is_nto_target = procfs_is_nto_target;
1355 }
1356
1357
1358 static int
1359 procfs_hw_watchpoint (int addr, int len, int type)
1360 {
1361   procfs_break brk;
1362
1363   switch (type)
1364     {
1365     case 1:                     /* Read.  */
1366       brk.type = _DEBUG_BREAK_RD;
1367       break;
1368     case 2:                     /* Read/Write.  */
1369       brk.type = _DEBUG_BREAK_RW;
1370       break;
1371     default:                    /* Modify.  */
1372 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason.  */
1373       brk.type = _DEBUG_BREAK_RW;
1374     }
1375   brk.type |= _DEBUG_BREAK_HW;  /* Always ask for HW.  */
1376   brk.addr = addr;
1377   brk.size = len;
1378
1379   errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1380   if (errno != EOK)
1381     {
1382       perror ("Failed to set hardware watchpoint");
1383       return -1;
1384     }
1385   return 0;
1386 }
1387
1388 static int
1389 procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
1390 {
1391   return 1;
1392 }
1393
1394 static int
1395 procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type)
1396 {
1397   return procfs_hw_watchpoint (addr, -1, type);
1398 }
1399
1400 static int
1401 procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type)
1402 {
1403   return procfs_hw_watchpoint (addr, len, type);
1404 }
1405
1406 static int
1407 procfs_stopped_by_watchpoint (void)
1408 {
1409   return 0;
1410 }