1 /* Machine independent support for QNX Neutrino /proc (process file system)
2 for GDB. Written by Colin Burgess at QNX Software Systems Limited.
4 Copyright (C) 2003-2014 Free Software Foundation, Inc.
6 Contributed by QNX Software Systems Ltd.
8 This file is part of GDB.
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.
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.
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/>. */
27 #include <sys/debug.h>
28 #include <sys/procfs.h>
29 #include <sys/neutrino.h>
30 #include <sys/syspage.h>
32 #include <sys/netmgr.h>
34 #include "exceptions.h"
40 #include "gdbthread.h"
47 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
48 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
50 static struct target_ops procfs_ops;
54 static void (*ofunc) ();
56 static procfs_run run;
58 static void procfs_open (char *, int);
60 static int procfs_can_run (void);
62 static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
63 struct mem_attrib *attrib,
66 static void init_procfs_ops (void);
68 static ptid_t do_attach (ptid_t ptid);
70 static int procfs_can_use_hw_breakpoint (int, int, int);
72 static int procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type,
73 struct expression *cond);
75 static int procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type,
76 struct expression *cond);
78 static int procfs_stopped_by_watchpoint (struct target_ops *ops);
80 /* These two globals are only ever set in procfs_open(), but are
81 referenced elsewhere. 'nto_procfs_node' is a flag used to say
82 whether we are local, or we should get the current node descriptor
83 for the remote QNX node. */
84 static char nto_procfs_path[PATH_MAX] = { "/proc" };
85 static unsigned nto_procfs_node = ND_LOCAL_NODE;
87 /* Return the current QNX Node, or error out. This is a simple
88 wrapper for the netmgr_strtond() function. The reason this
89 is required is because QNX node descriptors are transient so
90 we have to re-acquire them every time. */
96 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0)
99 node = netmgr_strtond (nto_procfs_path, 0);
101 error (_("Lost the QNX node. Debug session probably over."));
106 static enum gdb_osabi
107 procfs_is_nto_target (bfd *abfd)
109 return GDB_OSABI_QNXNTO;
112 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
113 For QNX6 (nto), the only valid arg will be a QNX node string,
114 eg: "/net/some_node". If arg is not a valid QNX node, we will
117 procfs_open (char *arg, int from_tty)
123 procfs_sysinfo *sysinfo;
124 struct cleanup *cleanups;
126 nto_is_nto_target = procfs_is_nto_target;
128 /* Set the default node used for spawning to this one,
129 and only override it if there is a valid arg. */
131 nto_procfs_node = ND_LOCAL_NODE;
132 nodestr = arg ? xstrdup (arg) : arg;
138 nto_procfs_node = netmgr_strtond (nodestr, &endstr);
139 if (nto_procfs_node == -1)
141 if (errno == ENOTSUP)
142 printf_filtered ("QNX Net Manager not found.\n");
143 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr,
144 errno, safe_strerror (errno));
147 nto_procfs_node = ND_LOCAL_NODE;
151 if (*(endstr - 1) == '/')
157 snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "",
162 fd = open (nto_procfs_path, O_RDONLY);
165 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
166 safe_strerror (errno));
167 error (_("Invalid procfs arg"));
169 cleanups = make_cleanup_close (fd);
171 sysinfo = (void *) buffer;
172 if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
174 printf_filtered ("Error getting size: %d (%s)\n", errno,
175 safe_strerror (errno));
176 error (_("Devctl failed."));
180 total_size = sysinfo->total_size;
181 sysinfo = alloca (total_size);
184 printf_filtered ("Memory error: %d (%s)\n", errno,
185 safe_strerror (errno));
186 error (_("alloca failed."));
190 if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
192 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
193 safe_strerror (errno));
194 error (_("Devctl failed."));
199 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
200 (target_gdbarch ())->arch_name))
201 error (_("Invalid target CPU."));
205 do_cleanups (cleanups);
206 printf_filtered ("Debugging using %s\n", nto_procfs_path);
210 procfs_set_thread (ptid_t ptid)
214 tid = ptid_get_tid (ptid);
215 devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
218 /* Return nonzero if the thread TH is still alive. */
220 procfs_thread_alive (struct target_ops *ops, ptid_t ptid)
224 procfs_status status;
227 tid = ptid_get_tid (ptid);
228 pid = ptid_get_pid (ptid);
230 if (kill (pid, 0) == -1)
234 if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS,
235 &status, sizeof (status), 0)) != EOK)
238 /* Thread is alive or dead but not yet joined,
239 or dead and there is an alive (or dead unjoined) thread with
242 If the tid is not the same as requested, requested tid is dead. */
243 return (status.tid == tid) && (status.state != STATE_DEAD);
247 update_thread_private_data_name (struct thread_info *new_thread,
251 struct private_thread_info *pti;
253 gdb_assert (newname != NULL);
254 gdb_assert (new_thread != NULL);
255 newnamelen = strlen (newname);
256 if (!new_thread->private)
258 new_thread->private = xmalloc (offsetof (struct private_thread_info,
261 memcpy (new_thread->private->name, newname, newnamelen + 1);
263 else if (strcmp (newname, new_thread->private->name) != 0)
265 /* Reallocate if neccessary. */
266 int oldnamelen = strlen (new_thread->private->name);
268 if (oldnamelen < newnamelen)
269 new_thread->private = xrealloc (new_thread->private,
270 offsetof (struct private_thread_info,
273 memcpy (new_thread->private->name, newname, newnamelen + 1);
278 update_thread_private_data (struct thread_info *new_thread,
279 pthread_t tid, int state, int flags)
281 struct private_thread_info *pti;
283 struct _thread_name *tn;
284 procfs_threadctl tctl;
286 #if _NTO_VERSION > 630
287 gdb_assert (new_thread != NULL);
289 if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo,
290 sizeof(pidinfo), 0) != EOK)
293 memset (&tctl, 0, sizeof (tctl));
294 tctl.cmd = _NTO_TCTL_NAME;
295 tn = (struct _thread_name *) (&tctl.data);
297 /* Fetch name for the given thread. */
299 tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn);
300 tn->new_name_len = -1; /* Getting, not setting. */
301 if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK)
302 tn->name_buf[0] = '\0';
304 tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0';
306 update_thread_private_data_name (new_thread, tn->name_buf);
308 pti = (struct private_thread_info *) new_thread->private;
312 #endif /* _NTO_VERSION */
316 procfs_find_new_threads (struct target_ops *ops)
318 procfs_status status;
322 struct thread_info *new_thread;
327 pid = ptid_get_pid (inferior_ptid);
331 for (tid = 1;; ++tid)
333 if (status.tid == tid
334 && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
337 if (status.tid != tid)
338 /* The reason why this would not be equal is that devctl might have
339 returned different tid, meaning the requested tid no longer exists
340 (e.g. thread exited). */
342 ptid = ptid_build (pid, 0, tid);
343 new_thread = find_thread_ptid (ptid);
345 new_thread = add_thread (ptid);
346 update_thread_private_data (new_thread, tid, status.state, 0);
353 do_closedir_cleanup (void *dir)
359 procfs_pidlist (char *args, int from_tty)
362 struct dirent *dirp = NULL;
364 procfs_info *pidinfo = NULL;
365 procfs_debuginfo *info = NULL;
366 procfs_status *status = NULL;
367 pid_t num_threads = 0;
370 struct cleanup *cleanups;
372 dp = opendir (nto_procfs_path);
375 fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
376 nto_procfs_path, errno, safe_strerror (errno));
380 cleanups = make_cleanup (do_closedir_cleanup, dp);
382 /* Start scan at first pid. */
388 struct cleanup *inner_cleanup;
390 /* Get the right pid and procfs path for the pid. */
396 do_cleanups (cleanups);
399 snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name);
400 pid = atoi (dirp->d_name);
404 /* Open the procfs path. */
405 fd = open (buf, O_RDONLY);
408 fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
409 buf, errno, safe_strerror (errno));
410 do_cleanups (cleanups);
413 inner_cleanup = make_cleanup_close (fd);
415 pidinfo = (procfs_info *) buf;
416 if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
418 fprintf_unfiltered (gdb_stderr,
419 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
420 errno, safe_strerror (errno));
423 num_threads = pidinfo->num_threads;
425 info = (procfs_debuginfo *) buf;
426 if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)
427 strcpy (name, "unavailable");
429 strcpy (name, info->path);
431 /* Collect state info on all the threads. */
432 status = (procfs_status *) buf;
433 for (status->tid = 1; status->tid <= num_threads; status->tid++)
435 if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK
438 if (status->tid != 0)
439 printf_filtered ("%s - %d/%d\n", name, pid, status->tid);
442 do_cleanups (inner_cleanup);
444 while (dirp != NULL);
446 do_cleanups (cleanups);
451 procfs_meminfo (char *args, int from_tty)
453 procfs_mapinfo *mapinfos = NULL;
454 static int num_mapinfos = 0;
455 procfs_mapinfo *mapinfo_p, *mapinfo_p2;
456 int flags = ~0, err, num, i, j;
460 procfs_debuginfo info;
461 char buff[_POSIX_PATH_MAX];
469 unsigned debug_vaddr;
470 unsigned long long offset;
475 unsigned long long ino;
482 /* Get the number of map entrys. */
483 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
486 printf ("failed devctl num mapinfos - %d (%s)\n", err,
487 safe_strerror (err));
491 mapinfos = xmalloc (num * sizeof (procfs_mapinfo));
494 mapinfo_p = mapinfos;
496 /* Fill the map entrys. */
497 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
498 * sizeof (procfs_mapinfo), &num);
501 printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
506 num = min (num, num_mapinfos);
508 /* Run through the list of mapinfos, and store the data and text info
509 so we can print it at the bottom of the loop. */
510 for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
512 if (!(mapinfo_p->flags & flags))
515 if (mapinfo_p->ino == 0) /* Already visited. */
518 map.info.vaddr = mapinfo_p->vaddr;
520 err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
524 memset (&printme, 0, sizeof printme);
525 printme.dev = mapinfo_p->dev;
526 printme.ino = mapinfo_p->ino;
527 printme.text.addr = mapinfo_p->vaddr;
528 printme.text.size = mapinfo_p->size;
529 printme.text.flags = mapinfo_p->flags;
530 printme.text.offset = mapinfo_p->offset;
531 printme.text.debug_vaddr = map.info.vaddr;
532 strcpy (printme.name, map.info.path);
534 /* Check for matching data. */
535 for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
537 if (mapinfo_p2->vaddr != mapinfo_p->vaddr
538 && mapinfo_p2->ino == mapinfo_p->ino
539 && mapinfo_p2->dev == mapinfo_p->dev)
541 map.info.vaddr = mapinfo_p2->vaddr;
543 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
547 if (strcmp (map.info.path, printme.name))
550 /* Lower debug_vaddr is always text, if nessessary, swap. */
551 if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
553 memcpy (&(printme.data), &(printme.text),
554 sizeof (printme.data));
555 printme.text.addr = mapinfo_p2->vaddr;
556 printme.text.size = mapinfo_p2->size;
557 printme.text.flags = mapinfo_p2->flags;
558 printme.text.offset = mapinfo_p2->offset;
559 printme.text.debug_vaddr = map.info.vaddr;
563 printme.data.addr = mapinfo_p2->vaddr;
564 printme.data.size = mapinfo_p2->size;
565 printme.data.flags = mapinfo_p2->flags;
566 printme.data.offset = mapinfo_p2->offset;
567 printme.data.debug_vaddr = map.info.vaddr;
574 printf_filtered ("%s\n", printme.name);
575 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
577 printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
578 printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
579 printf_filtered ("\t\toffset=%s\n", phex (printme.text.offset, 8));
580 if (printme.data.size)
582 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
584 printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
585 printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
586 printf_filtered ("\t\toffset=%s\n", phex (printme.data.offset, 8));
588 printf_filtered ("\tdev=0x%x\n", printme.dev);
589 printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
595 /* Print status information about what we're accessing. */
597 procfs_files_info (struct target_ops *ignore)
599 struct inferior *inf = current_inferior ();
601 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
602 inf->attach_flag ? "attached" : "child",
603 target_pid_to_str (inferior_ptid), nto_procfs_path);
606 /* Mark our target-struct as eligible for stray "run" and "attach"
609 procfs_can_run (void)
614 /* Attach to process PID, then initialize for debugging it. */
616 procfs_attach (struct target_ops *ops, char *args, int from_tty)
620 struct inferior *inf;
622 pid = parse_pid_to_attach (args);
624 if (pid == getpid ())
625 error (_("Attaching GDB to itself is not a good idea..."));
629 exec_file = (char *) get_exec_file (0);
632 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
633 target_pid_to_str (pid_to_ptid (pid)));
635 printf_unfiltered ("Attaching to %s\n",
636 target_pid_to_str (pid_to_ptid (pid)));
638 gdb_flush (gdb_stdout);
640 inferior_ptid = do_attach (pid_to_ptid (pid));
641 inf = current_inferior ();
642 inferior_appeared (inf, pid);
643 inf->attach_flag = 1;
647 procfs_find_new_threads (ops);
651 procfs_post_attach (struct target_ops *self, pid_t pid)
654 solib_create_inferior_hook (0);
658 do_attach (ptid_t ptid)
660 procfs_status status;
661 struct sigevent event;
664 snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path,
665 ptid_get_pid (ptid));
666 ctl_fd = open (path, O_RDWR);
668 error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
669 safe_strerror (errno));
670 if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
671 error (_("Couldn't stop process"));
673 /* Define a sigevent for process stopped notification. */
674 event.sigev_notify = SIGEV_SIGNAL_THREAD;
675 event.sigev_signo = SIGUSR1;
676 event.sigev_code = 0;
677 event.sigev_value.sival_ptr = NULL;
678 event.sigev_priority = -1;
679 devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
681 if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
682 && status.flags & _DEBUG_FLAG_STOPPED)
683 SignalKill (nto_node (), ptid_get_pid (ptid), 0, SIGCONT, 0, 0);
684 nto_init_solib_absolute_prefix ();
685 return ptid_build (ptid_get_pid (ptid), 0, status.tid);
688 /* Ask the user what to do when an interrupt is received. */
690 interrupt_query (void)
692 target_terminal_ours ();
694 if (query (_("Interrupted while waiting for the program.\n\
695 Give up (and stop debugging it)? ")))
697 target_mourn_inferior ();
701 target_terminal_inferior ();
704 /* The user typed ^C twice. */
706 nto_interrupt_twice (int signo)
708 signal (signo, ofunc);
710 signal (signo, nto_interrupt_twice);
714 nto_interrupt (int signo)
716 /* If this doesn't work, try more severe steps. */
717 signal (signo, nto_interrupt_twice);
719 target_stop (inferior_ptid);
723 procfs_wait (struct target_ops *ops,
724 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
728 procfs_status status;
729 static int exit_signo = 0; /* To track signals that cause termination. */
731 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
733 if (ptid_equal (inferior_ptid, null_ptid))
735 ourstatus->kind = TARGET_WAITKIND_STOPPED;
736 ourstatus->value.sig = GDB_SIGNAL_0;
742 sigaddset (&set, SIGUSR1);
744 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
745 while (!(status.flags & _DEBUG_FLAG_ISTOP))
747 ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
748 sigwaitinfo (&set, &info);
749 signal (SIGINT, ofunc);
750 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
753 if (status.flags & _DEBUG_FLAG_SSTEP)
755 ourstatus->kind = TARGET_WAITKIND_STOPPED;
756 ourstatus->value.sig = GDB_SIGNAL_TRAP;
758 /* Was it a breakpoint? */
759 else if (status.flags & _DEBUG_FLAG_TRACE)
761 ourstatus->kind = TARGET_WAITKIND_STOPPED;
762 ourstatus->value.sig = GDB_SIGNAL_TRAP;
764 else if (status.flags & _DEBUG_FLAG_ISTOP)
768 case _DEBUG_WHY_SIGNALLED:
769 ourstatus->kind = TARGET_WAITKIND_STOPPED;
770 ourstatus->value.sig =
771 gdb_signal_from_host (status.info.si_signo);
774 case _DEBUG_WHY_FAULTED:
775 ourstatus->kind = TARGET_WAITKIND_STOPPED;
776 if (status.info.si_signo == SIGTRAP)
778 ourstatus->value.sig = 0;
783 ourstatus->value.sig =
784 gdb_signal_from_host (status.info.si_signo);
785 exit_signo = ourstatus->value.sig;
789 case _DEBUG_WHY_TERMINATED:
793 waitpid (ptid_get_pid (inferior_ptid), &waitval, WNOHANG);
796 /* Abnormal death. */
797 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
798 ourstatus->value.sig = exit_signo;
803 ourstatus->kind = TARGET_WAITKIND_EXITED;
804 ourstatus->value.integer = WEXITSTATUS (waitval);
810 case _DEBUG_WHY_REQUESTED:
811 /* We are assuming a requested stop is due to a SIGINT. */
812 ourstatus->kind = TARGET_WAITKIND_STOPPED;
813 ourstatus->value.sig = GDB_SIGNAL_INT;
819 return ptid_build (status.pid, 0, status.tid);
822 /* Read the current values of the inferior's registers, both the
823 general register set and floating point registers (if supported)
824 and update gdb's idea of their current values. */
826 procfs_fetch_registers (struct target_ops *ops,
827 struct regcache *regcache, int regno)
833 procfs_altreg altreg;
838 procfs_set_thread (inferior_ptid);
839 if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK)
840 nto_supply_gregset (regcache, (char *) ®.greg);
841 if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size)
843 nto_supply_fpregset (regcache, (char *) ®.fpreg);
844 if (devctl (ctl_fd, DCMD_PROC_GETALTREG, ®, sizeof (reg), ®size)
846 nto_supply_altregset (regcache, (char *) ®.altreg);
849 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
850 from/to debugger memory starting at MYADDR. Copy from inferior
851 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
853 Returns the length copied, which is either the LEN argument or
854 zero. This xfer function does not do partial moves, since procfs_ops
855 doesn't allow memory operations to cross below us in the target stack
858 procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
859 struct mem_attrib *attrib, struct target_ops *target)
863 if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
866 nbytes = write (ctl_fd, myaddr, len);
868 nbytes = read (ctl_fd, myaddr, len);
875 /* Take a program previously attached to and detaches it.
876 The program resumes execution and will no longer stop
877 on signals, etc. We'd better not have left any breakpoints
878 in the program or it'll die when it hits one. */
880 procfs_detach (struct target_ops *ops, const char *args, int from_tty)
887 char *exec_file = get_exec_file (0);
890 printf_unfiltered ("Detaching from program: %s %s\n",
891 exec_file, target_pid_to_str (inferior_ptid));
892 gdb_flush (gdb_stdout);
895 siggnal = atoi (args);
898 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, siggnal, 0, 0);
903 pid = ptid_get_pid (inferior_ptid);
904 inferior_ptid = null_ptid;
905 detach_inferior (pid);
907 unpush_target (&procfs_ops); /* Pop out of handling an inferior. */
911 procfs_breakpoint (CORE_ADDR addr, int type, int size)
918 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
925 procfs_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
926 struct bp_target_info *bp_tgt)
928 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
932 procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
933 struct bp_target_info *bp_tgt)
935 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
939 procfs_insert_hw_breakpoint (struct gdbarch *gdbarch,
940 struct bp_target_info *bp_tgt)
942 return procfs_breakpoint (bp_tgt->placed_address,
943 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
947 procfs_remove_hw_breakpoint (struct gdbarch *gdbarch,
948 struct bp_target_info *bp_tgt)
950 return procfs_breakpoint (bp_tgt->placed_address,
951 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
955 procfs_resume (struct target_ops *ops,
956 ptid_t ptid, int step, enum gdb_signal signo)
959 procfs_status status;
960 sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
962 if (ptid_equal (inferior_ptid, null_ptid))
965 procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
968 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
970 run.flags |= _DEBUG_RUN_STEP;
972 sigemptyset (run_fault);
973 sigaddset (run_fault, FLTBPT);
974 sigaddset (run_fault, FLTTRACE);
975 sigaddset (run_fault, FLTILL);
976 sigaddset (run_fault, FLTPRIV);
977 sigaddset (run_fault, FLTBOUNDS);
978 sigaddset (run_fault, FLTIOVF);
979 sigaddset (run_fault, FLTIZDIV);
980 sigaddset (run_fault, FLTFPE);
981 /* Peter V will be changing this at some point. */
982 sigaddset (run_fault, FLTPAGE);
984 run.flags |= _DEBUG_RUN_ARM;
986 signal_to_pass = gdb_signal_to_host (signo);
990 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
991 signal_to_pass = gdb_signal_to_host (signo);
992 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
994 if (signal_to_pass != status.info.si_signo)
996 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0,
997 signal_to_pass, 0, 0);
998 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1000 else /* Let it kill the program without telling us. */
1001 sigdelset (&run.trace, signal_to_pass);
1005 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1007 errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1010 perror (_("run error!\n"));
1016 procfs_mourn_inferior (struct target_ops *ops)
1018 if (!ptid_equal (inferior_ptid, null_ptid))
1020 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, SIGKILL, 0, 0);
1023 inferior_ptid = null_ptid;
1024 init_thread_list ();
1025 unpush_target (&procfs_ops);
1026 generic_mourn_inferior ();
1029 /* This function breaks up an argument string into an argument
1030 vector suitable for passing to execvp().
1031 E.g., on "run a b c d" this routine would get as input
1032 the string "a b c d", and as output it would fill in argv with
1033 the four arguments "a", "b", "c", "d". The only additional
1034 functionality is simple quoting. The gdb command:
1036 will fill in argv with the three args "a", "b c d", "e". */
1038 breakup_args (char *scratch, char **argv)
1040 char *pp, *cp = scratch;
1045 /* Scan past leading separators. */
1047 while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1050 /* Break if at end of string. */
1058 quoting = strchr (cp, '"') ? 1 : 0;
1063 /* Scan for next arg separator. */
1066 cp = strchr (pp, '"');
1067 if ((cp == NULL) || (!quoting))
1068 cp = strchr (pp, ' ');
1070 cp = strchr (pp, '\t');
1072 cp = strchr (pp, '\n');
1074 /* No separators => end of string => break. */
1081 /* Replace the separator with a terminator. */
1085 /* Execv requires a null-terminated arg vector. */
1090 procfs_create_inferior (struct target_ops *ops, char *exec_file,
1091 char *allargs, char **env, int from_tty)
1093 struct inheritance inherit;
1097 const char *in = "", *out = "", *err = "";
1100 const char *inferior_io_terminal = get_inferior_io_terminal ();
1101 struct inferior *inf;
1103 argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
1105 argv[0] = get_exec_file (1);
1109 argv[0] = exec_file;
1114 args = xstrdup (allargs);
1115 breakup_args (args, exec_file ? &argv[1] : &argv[0]);
1117 argv = nto_parse_redirection (argv, &in, &out, &err);
1119 fds[0] = STDIN_FILENO;
1120 fds[1] = STDOUT_FILENO;
1121 fds[2] = STDERR_FILENO;
1123 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1124 if the i/o is not also being specified via redirection. */
1125 if (inferior_io_terminal)
1128 in = inferior_io_terminal;
1130 out = inferior_io_terminal;
1132 err = inferior_io_terminal;
1137 fd = open (in, O_RDONLY);
1145 fd = open (out, O_WRONLY);
1153 fd = open (err, O_WRONLY);
1160 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1161 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1164 sigaddset (&set, SIGUSR1);
1165 sigprocmask (SIG_UNBLOCK, &set, NULL);
1167 memset (&inherit, 0, sizeof (inherit));
1169 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1171 inherit.nd = nto_node ();
1172 inherit.flags |= SPAWN_SETND;
1173 inherit.flags &= ~SPAWN_EXEC;
1175 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1176 inherit.pgroup = SPAWN_NEWPGROUP;
1177 pid = spawnp (argv[0], 3, fds, &inherit, argv,
1178 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1181 sigprocmask (SIG_BLOCK, &set, NULL);
1184 error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1185 safe_strerror (errno));
1187 if (fds[0] != STDIN_FILENO)
1189 if (fds[1] != STDOUT_FILENO)
1191 if (fds[2] != STDERR_FILENO)
1194 inferior_ptid = do_attach (pid_to_ptid (pid));
1195 procfs_find_new_threads (ops);
1197 inf = current_inferior ();
1198 inferior_appeared (inf, pid);
1199 inf->attach_flag = 0;
1201 flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */
1202 errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1205 /* FIXME: expected warning? */
1206 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1207 errn, strerror(errn) ); */
1210 target_terminal_init ();
1212 if (exec_bfd != NULL
1213 || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1214 solib_create_inferior_hook (0);
1218 procfs_stop (ptid_t ptid)
1220 devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1224 procfs_kill_inferior (struct target_ops *ops)
1226 target_mourn_inferior ();
1229 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1232 procfs_prepare_to_store (struct target_ops *self, struct regcache *regcache)
1236 /* Fill buf with regset and return devctl cmd to do the setting. Return
1237 -1 if we fail to get the regset. Store size of regset in regsize. */
1239 get_regset (int regset, char *buf, int bufsize, int *regsize)
1241 int dev_get, dev_set;
1244 case NTO_REG_GENERAL:
1245 dev_get = DCMD_PROC_GETGREG;
1246 dev_set = DCMD_PROC_SETGREG;
1250 dev_get = DCMD_PROC_GETFPREG;
1251 dev_set = DCMD_PROC_SETFPREG;
1255 dev_get = DCMD_PROC_GETALTREG;
1256 dev_set = DCMD_PROC_SETALTREG;
1259 case NTO_REG_SYSTEM:
1263 if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1270 procfs_store_registers (struct target_ops *ops,
1271 struct regcache *regcache, int regno)
1277 procfs_altreg altreg;
1281 int len, regset, regsize, dev_set, err;
1284 if (ptid_equal (inferior_ptid, null_ptid))
1286 procfs_set_thread (inferior_ptid);
1290 for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1292 dev_set = get_regset (regset, (char *) ®,
1293 sizeof (reg), ®size);
1297 if (nto_regset_fill (regcache, regset, (char *) ®) == -1)
1300 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1302 fprintf_unfiltered (gdb_stderr,
1303 "Warning unable to write regset %d: %s\n",
1304 regno, safe_strerror (err));
1309 regset = nto_regset_id (regno);
1313 dev_set = get_regset (regset, (char *) ®, sizeof (reg), ®size);
1317 len = nto_register_area (get_regcache_arch (regcache),
1318 regno, regset, &off);
1323 regcache_raw_collect (regcache, regno, (char *) ® + off);
1325 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1327 fprintf_unfiltered (gdb_stderr,
1328 "Warning unable to write regset %d: %s\n", regno,
1329 safe_strerror (err));
1333 /* Set list of signals to be handled in the target. */
1336 procfs_pass_signals (int numsigs, unsigned char *pass_signals)
1340 sigfillset (&run.trace);
1342 for (signo = 1; signo < NSIG; signo++)
1344 int target_signo = gdb_signal_from_host (signo);
1345 if (target_signo < numsigs && pass_signals[target_signo])
1346 sigdelset (&run.trace, signo);
1350 static struct tidinfo *
1351 procfs_thread_info (pid_t pid, short tid)
1358 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
1360 static char buf[1024];
1362 struct tidinfo *tip;
1364 pid = ptid_get_pid (ptid);
1365 tid = ptid_get_tid (ptid);
1367 n = snprintf (buf, 1023, "process %d", pid);
1370 tip = procfs_thread_info (pid, tid);
1372 snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1379 init_procfs_ops (void)
1381 procfs_ops.to_shortname = "procfs";
1382 procfs_ops.to_longname = "QNX Neutrino procfs child process";
1384 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1385 target procfs <node>";
1386 procfs_ops.to_open = procfs_open;
1387 procfs_ops.to_attach = procfs_attach;
1388 procfs_ops.to_post_attach = procfs_post_attach;
1389 procfs_ops.to_detach = procfs_detach;
1390 procfs_ops.to_resume = procfs_resume;
1391 procfs_ops.to_wait = procfs_wait;
1392 procfs_ops.to_fetch_registers = procfs_fetch_registers;
1393 procfs_ops.to_store_registers = procfs_store_registers;
1394 procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
1395 procfs_ops.deprecated_xfer_memory = procfs_xfer_memory;
1396 procfs_ops.to_files_info = procfs_files_info;
1397 procfs_ops.to_insert_breakpoint = procfs_insert_breakpoint;
1398 procfs_ops.to_remove_breakpoint = procfs_remove_breakpoint;
1399 procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
1400 procfs_ops.to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
1401 procfs_ops.to_remove_hw_breakpoint = procfs_remove_breakpoint;
1402 procfs_ops.to_insert_watchpoint = procfs_insert_hw_watchpoint;
1403 procfs_ops.to_remove_watchpoint = procfs_remove_hw_watchpoint;
1404 procfs_ops.to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
1405 procfs_ops.to_terminal_init = terminal_init_inferior;
1406 procfs_ops.to_terminal_inferior = terminal_inferior;
1407 procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1408 procfs_ops.to_terminal_ours = terminal_ours;
1409 procfs_ops.to_terminal_info = child_terminal_info;
1410 procfs_ops.to_kill = procfs_kill_inferior;
1411 procfs_ops.to_create_inferior = procfs_create_inferior;
1412 procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
1413 procfs_ops.to_can_run = procfs_can_run;
1414 procfs_ops.to_pass_signals = procfs_pass_signals;
1415 procfs_ops.to_thread_alive = procfs_thread_alive;
1416 procfs_ops.to_find_new_threads = procfs_find_new_threads;
1417 procfs_ops.to_pid_to_str = procfs_pid_to_str;
1418 procfs_ops.to_stop = procfs_stop;
1419 procfs_ops.to_stratum = process_stratum;
1420 procfs_ops.to_has_all_memory = default_child_has_all_memory;
1421 procfs_ops.to_has_memory = default_child_has_memory;
1422 procfs_ops.to_has_stack = default_child_has_stack;
1423 procfs_ops.to_has_registers = default_child_has_registers;
1424 procfs_ops.to_has_execution = default_child_has_execution;
1425 procfs_ops.to_magic = OPS_MAGIC;
1426 procfs_ops.to_have_continuable_watchpoint = 1;
1427 procfs_ops.to_extra_thread_info = nto_extra_thread_info;
1430 #define OSTYPE_NTO 1
1433 _initialize_procfs (void)
1438 add_target (&procfs_ops);
1440 /* We use SIGUSR1 to gain control after we block waiting for a process.
1441 We use sigwaitevent to wait. */
1443 sigaddset (&set, SIGUSR1);
1444 sigprocmask (SIG_BLOCK, &set, NULL);
1446 /* Initially, make sure all signals are reported. */
1447 sigfillset (&run.trace);
1449 /* Stuff some information. */
1450 nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1451 nto_cpuinfo_valid = 1;
1453 add_info ("pidlist", procfs_pidlist, _("pidlist"));
1454 add_info ("meminfo", procfs_meminfo, _("memory information"));
1456 nto_is_nto_target = procfs_is_nto_target;
1461 procfs_hw_watchpoint (int addr, int len, int type)
1468 brk.type = _DEBUG_BREAK_RD;
1470 case 2: /* Read/Write. */
1471 brk.type = _DEBUG_BREAK_RW;
1473 default: /* Modify. */
1474 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1475 brk.type = _DEBUG_BREAK_RW;
1477 brk.type |= _DEBUG_BREAK_HW; /* Always ask for HW. */
1481 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1484 perror (_("Failed to set hardware watchpoint"));
1491 procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
1497 procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type,
1498 struct expression *cond)
1500 return procfs_hw_watchpoint (addr, -1, type);
1504 procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type,
1505 struct expression *cond)
1507 return procfs_hw_watchpoint (addr, len, type);
1511 procfs_stopped_by_watchpoint (struct target_ops *ops)