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 (struct target_ops *self);
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 (struct target_ops *self,
73 static int procfs_insert_hw_watchpoint (struct target_ops *self,
74 CORE_ADDR addr, int len, int type,
75 struct expression *cond);
77 static int procfs_remove_hw_watchpoint (struct target_ops *self,
78 CORE_ADDR addr, int len, int type,
79 struct expression *cond);
81 static int procfs_stopped_by_watchpoint (struct target_ops *ops);
83 /* These two globals are only ever set in procfs_open(), but are
84 referenced elsewhere. 'nto_procfs_node' is a flag used to say
85 whether we are local, or we should get the current node descriptor
86 for the remote QNX node. */
87 static char nto_procfs_path[PATH_MAX] = { "/proc" };
88 static unsigned nto_procfs_node = ND_LOCAL_NODE;
90 /* Return the current QNX Node, or error out. This is a simple
91 wrapper for the netmgr_strtond() function. The reason this
92 is required is because QNX node descriptors are transient so
93 we have to re-acquire them every time. */
99 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0)
100 return ND_LOCAL_NODE;
102 node = netmgr_strtond (nto_procfs_path, 0);
104 error (_("Lost the QNX node. Debug session probably over."));
109 static enum gdb_osabi
110 procfs_is_nto_target (bfd *abfd)
112 return GDB_OSABI_QNXNTO;
115 /* This is called when we call 'target procfs <arg>' from the (gdb) prompt.
116 For QNX6 (nto), the only valid arg will be a QNX node string,
117 eg: "/net/some_node". If arg is not a valid QNX node, we will
120 procfs_open (char *arg, int from_tty)
126 procfs_sysinfo *sysinfo;
127 struct cleanup *cleanups;
129 nto_is_nto_target = procfs_is_nto_target;
131 /* Set the default node used for spawning to this one,
132 and only override it if there is a valid arg. */
134 nto_procfs_node = ND_LOCAL_NODE;
135 nodestr = arg ? xstrdup (arg) : arg;
141 nto_procfs_node = netmgr_strtond (nodestr, &endstr);
142 if (nto_procfs_node == -1)
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));
150 nto_procfs_node = ND_LOCAL_NODE;
154 if (*(endstr - 1) == '/')
160 snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s", nodestr ? nodestr : "",
165 fd = open (nto_procfs_path, O_RDONLY);
168 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
169 safe_strerror (errno));
170 error (_("Invalid procfs arg"));
172 cleanups = make_cleanup_close (fd);
174 sysinfo = (void *) buffer;
175 if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
177 printf_filtered ("Error getting size: %d (%s)\n", errno,
178 safe_strerror (errno));
179 error (_("Devctl failed."));
183 total_size = sysinfo->total_size;
184 sysinfo = alloca (total_size);
187 printf_filtered ("Memory error: %d (%s)\n", errno,
188 safe_strerror (errno));
189 error (_("alloca failed."));
193 if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
195 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
196 safe_strerror (errno));
197 error (_("Devctl failed."));
202 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
203 (target_gdbarch ())->arch_name))
204 error (_("Invalid target CPU."));
208 do_cleanups (cleanups);
209 printf_filtered ("Debugging using %s\n", nto_procfs_path);
213 procfs_set_thread (ptid_t ptid)
217 tid = ptid_get_tid (ptid);
218 devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
221 /* Return nonzero if the thread TH is still alive. */
223 procfs_thread_alive (struct target_ops *ops, ptid_t ptid)
227 procfs_status status;
230 tid = ptid_get_tid (ptid);
231 pid = ptid_get_pid (ptid);
233 if (kill (pid, 0) == -1)
237 if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS,
238 &status, sizeof (status), 0)) != EOK)
241 /* Thread is alive or dead but not yet joined,
242 or dead and there is an alive (or dead unjoined) thread with
245 If the tid is not the same as requested, requested tid is dead. */
246 return (status.tid == tid) && (status.state != STATE_DEAD);
250 update_thread_private_data_name (struct thread_info *new_thread,
254 struct private_thread_info *pti;
256 gdb_assert (newname != NULL);
257 gdb_assert (new_thread != NULL);
258 newnamelen = strlen (newname);
259 if (!new_thread->private)
261 new_thread->private = xmalloc (offsetof (struct private_thread_info,
264 memcpy (new_thread->private->name, newname, newnamelen + 1);
266 else if (strcmp (newname, new_thread->private->name) != 0)
268 /* Reallocate if neccessary. */
269 int oldnamelen = strlen (new_thread->private->name);
271 if (oldnamelen < newnamelen)
272 new_thread->private = xrealloc (new_thread->private,
273 offsetof (struct private_thread_info,
276 memcpy (new_thread->private->name, newname, newnamelen + 1);
281 update_thread_private_data (struct thread_info *new_thread,
282 pthread_t tid, int state, int flags)
284 struct private_thread_info *pti;
286 struct _thread_name *tn;
287 procfs_threadctl tctl;
289 #if _NTO_VERSION > 630
290 gdb_assert (new_thread != NULL);
292 if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo,
293 sizeof(pidinfo), 0) != EOK)
296 memset (&tctl, 0, sizeof (tctl));
297 tctl.cmd = _NTO_TCTL_NAME;
298 tn = (struct _thread_name *) (&tctl.data);
300 /* Fetch name for the given thread. */
302 tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn);
303 tn->new_name_len = -1; /* Getting, not setting. */
304 if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK)
305 tn->name_buf[0] = '\0';
307 tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0';
309 update_thread_private_data_name (new_thread, tn->name_buf);
311 pti = (struct private_thread_info *) new_thread->private;
315 #endif /* _NTO_VERSION */
319 procfs_find_new_threads (struct target_ops *ops)
321 procfs_status status;
325 struct thread_info *new_thread;
330 pid = ptid_get_pid (inferior_ptid);
334 for (tid = 1;; ++tid)
336 if (status.tid == tid
337 && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
340 if (status.tid != tid)
341 /* The reason why this would not be equal is that devctl might have
342 returned different tid, meaning the requested tid no longer exists
343 (e.g. thread exited). */
345 ptid = ptid_build (pid, 0, tid);
346 new_thread = find_thread_ptid (ptid);
348 new_thread = add_thread (ptid);
349 update_thread_private_data (new_thread, tid, status.state, 0);
356 do_closedir_cleanup (void *dir)
362 procfs_pidlist (char *args, int from_tty)
365 struct dirent *dirp = NULL;
367 procfs_info *pidinfo = NULL;
368 procfs_debuginfo *info = NULL;
369 procfs_status *status = NULL;
370 pid_t num_threads = 0;
373 struct cleanup *cleanups;
375 dp = opendir (nto_procfs_path);
378 fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
379 nto_procfs_path, errno, safe_strerror (errno));
383 cleanups = make_cleanup (do_closedir_cleanup, dp);
385 /* Start scan at first pid. */
391 struct cleanup *inner_cleanup;
393 /* Get the right pid and procfs path for the pid. */
399 do_cleanups (cleanups);
402 snprintf (buf, 511, "%s/%s/as", nto_procfs_path, dirp->d_name);
403 pid = atoi (dirp->d_name);
407 /* Open the procfs path. */
408 fd = open (buf, O_RDONLY);
411 fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
412 buf, errno, safe_strerror (errno));
413 do_cleanups (cleanups);
416 inner_cleanup = make_cleanup_close (fd);
418 pidinfo = (procfs_info *) buf;
419 if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
421 fprintf_unfiltered (gdb_stderr,
422 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
423 errno, safe_strerror (errno));
426 num_threads = pidinfo->num_threads;
428 info = (procfs_debuginfo *) buf;
429 if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)
430 strcpy (name, "unavailable");
432 strcpy (name, info->path);
434 /* Collect state info on all the threads. */
435 status = (procfs_status *) buf;
436 for (status->tid = 1; status->tid <= num_threads; status->tid++)
438 if (devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0) != EOK
441 if (status->tid != 0)
442 printf_filtered ("%s - %d/%d\n", name, pid, status->tid);
445 do_cleanups (inner_cleanup);
447 while (dirp != NULL);
449 do_cleanups (cleanups);
454 procfs_meminfo (char *args, int from_tty)
456 procfs_mapinfo *mapinfos = NULL;
457 static int num_mapinfos = 0;
458 procfs_mapinfo *mapinfo_p, *mapinfo_p2;
459 int flags = ~0, err, num, i, j;
463 procfs_debuginfo info;
464 char buff[_POSIX_PATH_MAX];
472 unsigned debug_vaddr;
473 unsigned long long offset;
478 unsigned long long ino;
485 /* Get the number of map entrys. */
486 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
489 printf ("failed devctl num mapinfos - %d (%s)\n", err,
490 safe_strerror (err));
494 mapinfos = xmalloc (num * sizeof (procfs_mapinfo));
497 mapinfo_p = mapinfos;
499 /* Fill the map entrys. */
500 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
501 * sizeof (procfs_mapinfo), &num);
504 printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
509 num = min (num, num_mapinfos);
511 /* Run through the list of mapinfos, and store the data and text info
512 so we can print it at the bottom of the loop. */
513 for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
515 if (!(mapinfo_p->flags & flags))
518 if (mapinfo_p->ino == 0) /* Already visited. */
521 map.info.vaddr = mapinfo_p->vaddr;
523 err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
527 memset (&printme, 0, sizeof printme);
528 printme.dev = mapinfo_p->dev;
529 printme.ino = mapinfo_p->ino;
530 printme.text.addr = mapinfo_p->vaddr;
531 printme.text.size = mapinfo_p->size;
532 printme.text.flags = mapinfo_p->flags;
533 printme.text.offset = mapinfo_p->offset;
534 printme.text.debug_vaddr = map.info.vaddr;
535 strcpy (printme.name, map.info.path);
537 /* Check for matching data. */
538 for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
540 if (mapinfo_p2->vaddr != mapinfo_p->vaddr
541 && mapinfo_p2->ino == mapinfo_p->ino
542 && mapinfo_p2->dev == mapinfo_p->dev)
544 map.info.vaddr = mapinfo_p2->vaddr;
546 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
550 if (strcmp (map.info.path, printme.name))
553 /* Lower debug_vaddr is always text, if nessessary, swap. */
554 if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
556 memcpy (&(printme.data), &(printme.text),
557 sizeof (printme.data));
558 printme.text.addr = mapinfo_p2->vaddr;
559 printme.text.size = mapinfo_p2->size;
560 printme.text.flags = mapinfo_p2->flags;
561 printme.text.offset = mapinfo_p2->offset;
562 printme.text.debug_vaddr = map.info.vaddr;
566 printme.data.addr = mapinfo_p2->vaddr;
567 printme.data.size = mapinfo_p2->size;
568 printme.data.flags = mapinfo_p2->flags;
569 printme.data.offset = mapinfo_p2->offset;
570 printme.data.debug_vaddr = map.info.vaddr;
577 printf_filtered ("%s\n", printme.name);
578 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
580 printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
581 printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
582 printf_filtered ("\t\toffset=%s\n", phex (printme.text.offset, 8));
583 if (printme.data.size)
585 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
587 printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
588 printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
589 printf_filtered ("\t\toffset=%s\n", phex (printme.data.offset, 8));
591 printf_filtered ("\tdev=0x%x\n", printme.dev);
592 printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
598 /* Print status information about what we're accessing. */
600 procfs_files_info (struct target_ops *ignore)
602 struct inferior *inf = current_inferior ();
604 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
605 inf->attach_flag ? "attached" : "child",
606 target_pid_to_str (inferior_ptid), nto_procfs_path);
609 /* Mark our target-struct as eligible for stray "run" and "attach"
612 procfs_can_run (struct target_ops *self)
617 /* Attach to process PID, then initialize for debugging it. */
619 procfs_attach (struct target_ops *ops, char *args, int from_tty)
623 struct inferior *inf;
625 pid = parse_pid_to_attach (args);
627 if (pid == getpid ())
628 error (_("Attaching GDB to itself is not a good idea..."));
632 exec_file = (char *) get_exec_file (0);
635 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
636 target_pid_to_str (pid_to_ptid (pid)));
638 printf_unfiltered ("Attaching to %s\n",
639 target_pid_to_str (pid_to_ptid (pid)));
641 gdb_flush (gdb_stdout);
643 inferior_ptid = do_attach (pid_to_ptid (pid));
644 inf = current_inferior ();
645 inferior_appeared (inf, pid);
646 inf->attach_flag = 1;
650 procfs_find_new_threads (ops);
654 procfs_post_attach (struct target_ops *self, pid_t pid)
657 solib_create_inferior_hook (0);
661 do_attach (ptid_t ptid)
663 procfs_status status;
664 struct sigevent event;
667 snprintf (path, PATH_MAX - 1, "%s/%d/as", nto_procfs_path,
668 ptid_get_pid (ptid));
669 ctl_fd = open (path, O_RDWR);
671 error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
672 safe_strerror (errno));
673 if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
674 error (_("Couldn't stop process"));
676 /* Define a sigevent for process stopped notification. */
677 event.sigev_notify = SIGEV_SIGNAL_THREAD;
678 event.sigev_signo = SIGUSR1;
679 event.sigev_code = 0;
680 event.sigev_value.sival_ptr = NULL;
681 event.sigev_priority = -1;
682 devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
684 if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
685 && status.flags & _DEBUG_FLAG_STOPPED)
686 SignalKill (nto_node (), ptid_get_pid (ptid), 0, SIGCONT, 0, 0);
687 nto_init_solib_absolute_prefix ();
688 return ptid_build (ptid_get_pid (ptid), 0, status.tid);
691 /* Ask the user what to do when an interrupt is received. */
693 interrupt_query (void)
695 target_terminal_ours ();
697 if (query (_("Interrupted while waiting for the program.\n\
698 Give up (and stop debugging it)? ")))
700 target_mourn_inferior ();
704 target_terminal_inferior ();
707 /* The user typed ^C twice. */
709 nto_interrupt_twice (int signo)
711 signal (signo, ofunc);
713 signal (signo, nto_interrupt_twice);
717 nto_interrupt (int signo)
719 /* If this doesn't work, try more severe steps. */
720 signal (signo, nto_interrupt_twice);
722 target_stop (inferior_ptid);
726 procfs_wait (struct target_ops *ops,
727 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
731 procfs_status status;
732 static int exit_signo = 0; /* To track signals that cause termination. */
734 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
736 if (ptid_equal (inferior_ptid, null_ptid))
738 ourstatus->kind = TARGET_WAITKIND_STOPPED;
739 ourstatus->value.sig = GDB_SIGNAL_0;
745 sigaddset (&set, SIGUSR1);
747 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
748 while (!(status.flags & _DEBUG_FLAG_ISTOP))
750 ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
751 sigwaitinfo (&set, &info);
752 signal (SIGINT, ofunc);
753 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
756 if (status.flags & _DEBUG_FLAG_SSTEP)
758 ourstatus->kind = TARGET_WAITKIND_STOPPED;
759 ourstatus->value.sig = GDB_SIGNAL_TRAP;
761 /* Was it a breakpoint? */
762 else if (status.flags & _DEBUG_FLAG_TRACE)
764 ourstatus->kind = TARGET_WAITKIND_STOPPED;
765 ourstatus->value.sig = GDB_SIGNAL_TRAP;
767 else if (status.flags & _DEBUG_FLAG_ISTOP)
771 case _DEBUG_WHY_SIGNALLED:
772 ourstatus->kind = TARGET_WAITKIND_STOPPED;
773 ourstatus->value.sig =
774 gdb_signal_from_host (status.info.si_signo);
777 case _DEBUG_WHY_FAULTED:
778 ourstatus->kind = TARGET_WAITKIND_STOPPED;
779 if (status.info.si_signo == SIGTRAP)
781 ourstatus->value.sig = 0;
786 ourstatus->value.sig =
787 gdb_signal_from_host (status.info.si_signo);
788 exit_signo = ourstatus->value.sig;
792 case _DEBUG_WHY_TERMINATED:
796 waitpid (ptid_get_pid (inferior_ptid), &waitval, WNOHANG);
799 /* Abnormal death. */
800 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
801 ourstatus->value.sig = exit_signo;
806 ourstatus->kind = TARGET_WAITKIND_EXITED;
807 ourstatus->value.integer = WEXITSTATUS (waitval);
813 case _DEBUG_WHY_REQUESTED:
814 /* We are assuming a requested stop is due to a SIGINT. */
815 ourstatus->kind = TARGET_WAITKIND_STOPPED;
816 ourstatus->value.sig = GDB_SIGNAL_INT;
822 return ptid_build (status.pid, 0, status.tid);
825 /* Read the current values of the inferior's registers, both the
826 general register set and floating point registers (if supported)
827 and update gdb's idea of their current values. */
829 procfs_fetch_registers (struct target_ops *ops,
830 struct regcache *regcache, int regno)
836 procfs_altreg altreg;
841 procfs_set_thread (inferior_ptid);
842 if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK)
843 nto_supply_gregset (regcache, (char *) ®.greg);
844 if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size)
846 nto_supply_fpregset (regcache, (char *) ®.fpreg);
847 if (devctl (ctl_fd, DCMD_PROC_GETALTREG, ®, sizeof (reg), ®size)
849 nto_supply_altregset (regcache, (char *) ®.altreg);
852 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
853 from/to debugger memory starting at MYADDR. Copy from inferior
854 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
856 Returns the length copied, which is either the LEN argument or
857 zero. This xfer function does not do partial moves, since procfs_ops
858 doesn't allow memory operations to cross below us in the target stack
861 procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
862 struct mem_attrib *attrib, struct target_ops *target)
866 if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
869 nbytes = write (ctl_fd, myaddr, len);
871 nbytes = read (ctl_fd, myaddr, len);
878 /* Take a program previously attached to and detaches it.
879 The program resumes execution and will no longer stop
880 on signals, etc. We'd better not have left any breakpoints
881 in the program or it'll die when it hits one. */
883 procfs_detach (struct target_ops *ops, const char *args, int from_tty)
890 char *exec_file = get_exec_file (0);
893 printf_unfiltered ("Detaching from program: %s %s\n",
894 exec_file, target_pid_to_str (inferior_ptid));
895 gdb_flush (gdb_stdout);
898 siggnal = atoi (args);
901 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, siggnal, 0, 0);
906 pid = ptid_get_pid (inferior_ptid);
907 inferior_ptid = null_ptid;
908 detach_inferior (pid);
910 unpush_target (&procfs_ops); /* Pop out of handling an inferior. */
914 procfs_breakpoint (CORE_ADDR addr, int type, int size)
921 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
928 procfs_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
929 struct bp_target_info *bp_tgt)
931 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
935 procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
936 struct bp_target_info *bp_tgt)
938 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
942 procfs_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
943 struct bp_target_info *bp_tgt)
945 return procfs_breakpoint (bp_tgt->placed_address,
946 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
950 procfs_remove_hw_breakpoint (struct gdbarch *gdbarch,
951 struct bp_target_info *bp_tgt)
953 return procfs_breakpoint (bp_tgt->placed_address,
954 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
958 procfs_resume (struct target_ops *ops,
959 ptid_t ptid, int step, enum gdb_signal signo)
962 procfs_status status;
963 sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
965 if (ptid_equal (inferior_ptid, null_ptid))
968 procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
971 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
973 run.flags |= _DEBUG_RUN_STEP;
975 sigemptyset (run_fault);
976 sigaddset (run_fault, FLTBPT);
977 sigaddset (run_fault, FLTTRACE);
978 sigaddset (run_fault, FLTILL);
979 sigaddset (run_fault, FLTPRIV);
980 sigaddset (run_fault, FLTBOUNDS);
981 sigaddset (run_fault, FLTIOVF);
982 sigaddset (run_fault, FLTIZDIV);
983 sigaddset (run_fault, FLTFPE);
984 /* Peter V will be changing this at some point. */
985 sigaddset (run_fault, FLTPAGE);
987 run.flags |= _DEBUG_RUN_ARM;
989 signal_to_pass = gdb_signal_to_host (signo);
993 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
994 signal_to_pass = gdb_signal_to_host (signo);
995 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
997 if (signal_to_pass != status.info.si_signo)
999 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0,
1000 signal_to_pass, 0, 0);
1001 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1003 else /* Let it kill the program without telling us. */
1004 sigdelset (&run.trace, signal_to_pass);
1008 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1010 errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1013 perror (_("run error!\n"));
1019 procfs_mourn_inferior (struct target_ops *ops)
1021 if (!ptid_equal (inferior_ptid, null_ptid))
1023 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, SIGKILL, 0, 0);
1026 inferior_ptid = null_ptid;
1027 init_thread_list ();
1028 unpush_target (&procfs_ops);
1029 generic_mourn_inferior ();
1032 /* This function breaks up an argument string into an argument
1033 vector suitable for passing to execvp().
1034 E.g., on "run a b c d" this routine would get as input
1035 the string "a b c d", and as output it would fill in argv with
1036 the four arguments "a", "b", "c", "d". The only additional
1037 functionality is simple quoting. The gdb command:
1039 will fill in argv with the three args "a", "b c d", "e". */
1041 breakup_args (char *scratch, char **argv)
1043 char *pp, *cp = scratch;
1048 /* Scan past leading separators. */
1050 while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1053 /* Break if at end of string. */
1061 quoting = strchr (cp, '"') ? 1 : 0;
1066 /* Scan for next arg separator. */
1069 cp = strchr (pp, '"');
1070 if ((cp == NULL) || (!quoting))
1071 cp = strchr (pp, ' ');
1073 cp = strchr (pp, '\t');
1075 cp = strchr (pp, '\n');
1077 /* No separators => end of string => break. */
1084 /* Replace the separator with a terminator. */
1088 /* Execv requires a null-terminated arg vector. */
1093 procfs_create_inferior (struct target_ops *ops, char *exec_file,
1094 char *allargs, char **env, int from_tty)
1096 struct inheritance inherit;
1100 const char *in = "", *out = "", *err = "";
1103 const char *inferior_io_terminal = get_inferior_io_terminal ();
1104 struct inferior *inf;
1106 argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
1108 argv[0] = get_exec_file (1);
1112 argv[0] = exec_file;
1117 args = xstrdup (allargs);
1118 breakup_args (args, exec_file ? &argv[1] : &argv[0]);
1120 argv = nto_parse_redirection (argv, &in, &out, &err);
1122 fds[0] = STDIN_FILENO;
1123 fds[1] = STDOUT_FILENO;
1124 fds[2] = STDERR_FILENO;
1126 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1127 if the i/o is not also being specified via redirection. */
1128 if (inferior_io_terminal)
1131 in = inferior_io_terminal;
1133 out = inferior_io_terminal;
1135 err = inferior_io_terminal;
1140 fd = open (in, O_RDONLY);
1148 fd = open (out, O_WRONLY);
1156 fd = open (err, O_WRONLY);
1163 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1164 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1167 sigaddset (&set, SIGUSR1);
1168 sigprocmask (SIG_UNBLOCK, &set, NULL);
1170 memset (&inherit, 0, sizeof (inherit));
1172 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1174 inherit.nd = nto_node ();
1175 inherit.flags |= SPAWN_SETND;
1176 inherit.flags &= ~SPAWN_EXEC;
1178 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1179 inherit.pgroup = SPAWN_NEWPGROUP;
1180 pid = spawnp (argv[0], 3, fds, &inherit, argv,
1181 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1184 sigprocmask (SIG_BLOCK, &set, NULL);
1187 error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1188 safe_strerror (errno));
1190 if (fds[0] != STDIN_FILENO)
1192 if (fds[1] != STDOUT_FILENO)
1194 if (fds[2] != STDERR_FILENO)
1197 inferior_ptid = do_attach (pid_to_ptid (pid));
1198 procfs_find_new_threads (ops);
1200 inf = current_inferior ();
1201 inferior_appeared (inf, pid);
1202 inf->attach_flag = 0;
1204 flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */
1205 errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1208 /* FIXME: expected warning? */
1209 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1210 errn, strerror(errn) ); */
1213 target_terminal_init ();
1215 if (exec_bfd != NULL
1216 || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1217 solib_create_inferior_hook (0);
1221 procfs_stop (ptid_t ptid)
1223 devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1227 procfs_kill_inferior (struct target_ops *ops)
1229 target_mourn_inferior ();
1232 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1235 procfs_prepare_to_store (struct target_ops *self, struct regcache *regcache)
1239 /* Fill buf with regset and return devctl cmd to do the setting. Return
1240 -1 if we fail to get the regset. Store size of regset in regsize. */
1242 get_regset (int regset, char *buf, int bufsize, int *regsize)
1244 int dev_get, dev_set;
1247 case NTO_REG_GENERAL:
1248 dev_get = DCMD_PROC_GETGREG;
1249 dev_set = DCMD_PROC_SETGREG;
1253 dev_get = DCMD_PROC_GETFPREG;
1254 dev_set = DCMD_PROC_SETFPREG;
1258 dev_get = DCMD_PROC_GETALTREG;
1259 dev_set = DCMD_PROC_SETALTREG;
1262 case NTO_REG_SYSTEM:
1266 if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1273 procfs_store_registers (struct target_ops *ops,
1274 struct regcache *regcache, int regno)
1280 procfs_altreg altreg;
1284 int len, regset, regsize, dev_set, err;
1287 if (ptid_equal (inferior_ptid, null_ptid))
1289 procfs_set_thread (inferior_ptid);
1293 for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1295 dev_set = get_regset (regset, (char *) ®,
1296 sizeof (reg), ®size);
1300 if (nto_regset_fill (regcache, regset, (char *) ®) == -1)
1303 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1305 fprintf_unfiltered (gdb_stderr,
1306 "Warning unable to write regset %d: %s\n",
1307 regno, safe_strerror (err));
1312 regset = nto_regset_id (regno);
1316 dev_set = get_regset (regset, (char *) ®, sizeof (reg), ®size);
1320 len = nto_register_area (get_regcache_arch (regcache),
1321 regno, regset, &off);
1326 regcache_raw_collect (regcache, regno, (char *) ® + off);
1328 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1330 fprintf_unfiltered (gdb_stderr,
1331 "Warning unable to write regset %d: %s\n", regno,
1332 safe_strerror (err));
1336 /* Set list of signals to be handled in the target. */
1339 procfs_pass_signals (struct target_ops *self,
1340 int numsigs, unsigned char *pass_signals)
1344 sigfillset (&run.trace);
1346 for (signo = 1; signo < NSIG; signo++)
1348 int target_signo = gdb_signal_from_host (signo);
1349 if (target_signo < numsigs && pass_signals[target_signo])
1350 sigdelset (&run.trace, signo);
1354 static struct tidinfo *
1355 procfs_thread_info (pid_t pid, short tid)
1362 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
1364 static char buf[1024];
1366 struct tidinfo *tip;
1368 pid = ptid_get_pid (ptid);
1369 tid = ptid_get_tid (ptid);
1371 n = snprintf (buf, 1023, "process %d", pid);
1374 tip = procfs_thread_info (pid, tid);
1376 snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1383 init_procfs_ops (void)
1385 procfs_ops.to_shortname = "procfs";
1386 procfs_ops.to_longname = "QNX Neutrino procfs child process";
1388 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1389 target procfs <node>";
1390 procfs_ops.to_open = procfs_open;
1391 procfs_ops.to_attach = procfs_attach;
1392 procfs_ops.to_post_attach = procfs_post_attach;
1393 procfs_ops.to_detach = procfs_detach;
1394 procfs_ops.to_resume = procfs_resume;
1395 procfs_ops.to_wait = procfs_wait;
1396 procfs_ops.to_fetch_registers = procfs_fetch_registers;
1397 procfs_ops.to_store_registers = procfs_store_registers;
1398 procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
1399 procfs_ops.deprecated_xfer_memory = procfs_xfer_memory;
1400 procfs_ops.to_files_info = procfs_files_info;
1401 procfs_ops.to_insert_breakpoint = procfs_insert_breakpoint;
1402 procfs_ops.to_remove_breakpoint = procfs_remove_breakpoint;
1403 procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
1404 procfs_ops.to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
1405 procfs_ops.to_remove_hw_breakpoint = procfs_remove_breakpoint;
1406 procfs_ops.to_insert_watchpoint = procfs_insert_hw_watchpoint;
1407 procfs_ops.to_remove_watchpoint = procfs_remove_hw_watchpoint;
1408 procfs_ops.to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
1409 procfs_ops.to_terminal_init = terminal_init_inferior;
1410 procfs_ops.to_terminal_inferior = terminal_inferior;
1411 procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1412 procfs_ops.to_terminal_ours = terminal_ours;
1413 procfs_ops.to_terminal_info = child_terminal_info;
1414 procfs_ops.to_kill = procfs_kill_inferior;
1415 procfs_ops.to_create_inferior = procfs_create_inferior;
1416 procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
1417 procfs_ops.to_can_run = procfs_can_run;
1418 procfs_ops.to_pass_signals = procfs_pass_signals;
1419 procfs_ops.to_thread_alive = procfs_thread_alive;
1420 procfs_ops.to_find_new_threads = procfs_find_new_threads;
1421 procfs_ops.to_pid_to_str = procfs_pid_to_str;
1422 procfs_ops.to_stop = procfs_stop;
1423 procfs_ops.to_stratum = process_stratum;
1424 procfs_ops.to_has_all_memory = default_child_has_all_memory;
1425 procfs_ops.to_has_memory = default_child_has_memory;
1426 procfs_ops.to_has_stack = default_child_has_stack;
1427 procfs_ops.to_has_registers = default_child_has_registers;
1428 procfs_ops.to_has_execution = default_child_has_execution;
1429 procfs_ops.to_magic = OPS_MAGIC;
1430 procfs_ops.to_have_continuable_watchpoint = 1;
1431 procfs_ops.to_extra_thread_info = nto_extra_thread_info;
1434 #define OSTYPE_NTO 1
1437 _initialize_procfs (void)
1442 add_target (&procfs_ops);
1444 /* We use SIGUSR1 to gain control after we block waiting for a process.
1445 We use sigwaitevent to wait. */
1447 sigaddset (&set, SIGUSR1);
1448 sigprocmask (SIG_BLOCK, &set, NULL);
1450 /* Initially, make sure all signals are reported. */
1451 sigfillset (&run.trace);
1453 /* Stuff some information. */
1454 nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1455 nto_cpuinfo_valid = 1;
1457 add_info ("pidlist", procfs_pidlist, _("pidlist"));
1458 add_info ("meminfo", procfs_meminfo, _("memory information"));
1460 nto_is_nto_target = procfs_is_nto_target;
1465 procfs_hw_watchpoint (int addr, int len, int type)
1472 brk.type = _DEBUG_BREAK_RD;
1474 case 2: /* Read/Write. */
1475 brk.type = _DEBUG_BREAK_RW;
1477 default: /* Modify. */
1478 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1479 brk.type = _DEBUG_BREAK_RW;
1481 brk.type |= _DEBUG_BREAK_HW; /* Always ask for HW. */
1485 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1488 perror (_("Failed to set hardware watchpoint"));
1495 procfs_can_use_hw_breakpoint (struct target_ops *self,
1496 int type, int cnt, int othertype)
1502 procfs_remove_hw_watchpoint (struct target_ops *self,
1503 CORE_ADDR addr, int len, int type,
1504 struct expression *cond)
1506 return procfs_hw_watchpoint (addr, -1, type);
1510 procfs_insert_hw_watchpoint (struct target_ops *self,
1511 CORE_ADDR addr, int len, int type,
1512 struct expression *cond)
1514 return procfs_hw_watchpoint (addr, len, type);
1518 procfs_stopped_by_watchpoint (struct target_ops *ops)