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, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 Contributed by QNX Software Systems Ltd.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include <sys/debug.h>
29 #include <sys/procfs.h>
30 #include <sys/neutrino.h>
31 #include <sys/syspage.h>
32 #include "gdb_dirent.h"
33 #include <sys/netmgr.h>
35 #include "exceptions.h"
36 #include "gdb_string.h"
41 #include "gdbthread.h"
48 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
49 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
51 static struct target_ops procfs_ops;
55 static void (*ofunc) ();
57 static procfs_run run;
59 static void procfs_open (char *, int);
61 static int procfs_can_run (void);
63 static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
64 struct mem_attrib *attrib,
67 static void notice_signals (void);
69 static void init_procfs_ops (void);
71 static ptid_t do_attach (ptid_t ptid);
73 static int procfs_can_use_hw_breakpoint (int, int, int);
75 static int procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type,
76 struct expression *cond);
78 static int procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type,
79 struct expression *cond);
81 static int procfs_stopped_by_watchpoint (void);
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 (void)
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 (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, PIDGET (ptid));
668 ctl_fd = open (path, O_RDWR);
670 error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
671 safe_strerror (errno));
672 if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
673 error (_("Couldn't stop process"));
675 /* Define a sigevent for process stopped notification. */
676 event.sigev_notify = SIGEV_SIGNAL_THREAD;
677 event.sigev_signo = SIGUSR1;
678 event.sigev_code = 0;
679 event.sigev_value.sival_ptr = NULL;
680 event.sigev_priority = -1;
681 devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
683 if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
684 && status.flags & _DEBUG_FLAG_STOPPED)
685 SignalKill (nto_node (), PIDGET (ptid), 0, SIGCONT, 0, 0);
686 nto_init_solib_absolute_prefix ();
687 return ptid_build (PIDGET (ptid), 0, status.tid);
690 /* Ask the user what to do when an interrupt is received. */
692 interrupt_query (void)
694 target_terminal_ours ();
696 if (query (_("Interrupted while waiting for the program.\n\
697 Give up (and stop debugging it)? ")))
699 target_mourn_inferior ();
700 deprecated_throw_reason (RETURN_QUIT);
703 target_terminal_inferior ();
706 /* The user typed ^C twice. */
708 nto_interrupt_twice (int signo)
710 signal (signo, ofunc);
712 signal (signo, nto_interrupt_twice);
716 nto_interrupt (int signo)
718 /* If this doesn't work, try more severe steps. */
719 signal (signo, nto_interrupt_twice);
721 target_stop (inferior_ptid);
725 procfs_wait (struct target_ops *ops,
726 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
730 procfs_status status;
731 static int exit_signo = 0; /* To track signals that cause termination. */
733 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
735 if (ptid_equal (inferior_ptid, null_ptid))
737 ourstatus->kind = TARGET_WAITKIND_STOPPED;
738 ourstatus->value.sig = TARGET_SIGNAL_0;
744 sigaddset (&set, SIGUSR1);
746 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
747 while (!(status.flags & _DEBUG_FLAG_ISTOP))
749 ofunc = (void (*)()) signal (SIGINT, nto_interrupt);
750 sigwaitinfo (&set, &info);
751 signal (SIGINT, ofunc);
752 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
755 if (status.flags & _DEBUG_FLAG_SSTEP)
757 ourstatus->kind = TARGET_WAITKIND_STOPPED;
758 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
760 /* Was it a breakpoint? */
761 else if (status.flags & _DEBUG_FLAG_TRACE)
763 ourstatus->kind = TARGET_WAITKIND_STOPPED;
764 ourstatus->value.sig = TARGET_SIGNAL_TRAP;
766 else if (status.flags & _DEBUG_FLAG_ISTOP)
770 case _DEBUG_WHY_SIGNALLED:
771 ourstatus->kind = TARGET_WAITKIND_STOPPED;
772 ourstatus->value.sig =
773 target_signal_from_host (status.info.si_signo);
776 case _DEBUG_WHY_FAULTED:
777 ourstatus->kind = TARGET_WAITKIND_STOPPED;
778 if (status.info.si_signo == SIGTRAP)
780 ourstatus->value.sig = 0;
785 ourstatus->value.sig =
786 target_signal_from_host (status.info.si_signo);
787 exit_signo = ourstatus->value.sig;
791 case _DEBUG_WHY_TERMINATED:
795 waitpid (PIDGET (inferior_ptid), &waitval, WNOHANG);
798 /* Abnormal death. */
799 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
800 ourstatus->value.sig = exit_signo;
805 ourstatus->kind = TARGET_WAITKIND_EXITED;
806 ourstatus->value.integer = WEXITSTATUS (waitval);
812 case _DEBUG_WHY_REQUESTED:
813 /* We are assuming a requested stop is due to a SIGINT. */
814 ourstatus->kind = TARGET_WAITKIND_STOPPED;
815 ourstatus->value.sig = TARGET_SIGNAL_INT;
821 return ptid_build (status.pid, 0, status.tid);
824 /* Read the current values of the inferior's registers, both the
825 general register set and floating point registers (if supported)
826 and update gdb's idea of their current values. */
828 procfs_fetch_registers (struct target_ops *ops,
829 struct regcache *regcache, int regno)
835 procfs_altreg altreg;
840 procfs_set_thread (inferior_ptid);
841 if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK)
842 nto_supply_gregset (regcache, (char *) ®.greg);
843 if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size)
845 nto_supply_fpregset (regcache, (char *) ®.fpreg);
846 if (devctl (ctl_fd, DCMD_PROC_GETALTREG, ®, sizeof (reg), ®size)
848 nto_supply_altregset (regcache, (char *) ®.altreg);
851 /* Copy LEN bytes to/from inferior's memory starting at MEMADDR
852 from/to debugger memory starting at MYADDR. Copy from inferior
853 if DOWRITE is zero or to inferior if DOWRITE is nonzero.
855 Returns the length copied, which is either the LEN argument or
856 zero. This xfer function does not do partial moves, since procfs_ops
857 doesn't allow memory operations to cross below us in the target stack
860 procfs_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int dowrite,
861 struct mem_attrib *attrib, struct target_ops *target)
865 if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) == (off_t) memaddr)
868 nbytes = write (ctl_fd, myaddr, len);
870 nbytes = read (ctl_fd, myaddr, len);
877 /* Take a program previously attached to and detaches it.
878 The program resumes execution and will no longer stop
879 on signals, etc. We'd better not have left any breakpoints
880 in the program or it'll die when it hits one. */
882 procfs_detach (struct target_ops *ops, char *args, int from_tty)
889 char *exec_file = get_exec_file (0);
892 printf_unfiltered ("Detaching from program: %s %s\n",
893 exec_file, target_pid_to_str (inferior_ptid));
894 gdb_flush (gdb_stdout);
897 siggnal = atoi (args);
900 SignalKill (nto_node (), PIDGET (inferior_ptid), 0, siggnal, 0, 0);
905 pid = ptid_get_pid (inferior_ptid);
906 inferior_ptid = null_ptid;
907 detach_inferior (pid);
909 unpush_target (&procfs_ops); /* Pop out of handling an inferior. */
913 procfs_breakpoint (CORE_ADDR addr, int type, int size)
920 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
927 procfs_insert_breakpoint (struct gdbarch *gdbarch,
928 struct bp_target_info *bp_tgt)
930 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
934 procfs_remove_breakpoint (struct gdbarch *gdbarch,
935 struct bp_target_info *bp_tgt)
937 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
941 procfs_insert_hw_breakpoint (struct gdbarch *gdbarch,
942 struct bp_target_info *bp_tgt)
944 return procfs_breakpoint (bp_tgt->placed_address,
945 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
949 procfs_remove_hw_breakpoint (struct gdbarch *gdbarch,
950 struct bp_target_info *bp_tgt)
952 return procfs_breakpoint (bp_tgt->placed_address,
953 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
957 procfs_resume (struct target_ops *ops,
958 ptid_t ptid, int step, enum target_signal signo)
961 procfs_status status;
962 sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
964 if (ptid_equal (inferior_ptid, null_ptid))
967 procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
970 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
972 run.flags |= _DEBUG_RUN_STEP;
974 sigemptyset (run_fault);
975 sigaddset (run_fault, FLTBPT);
976 sigaddset (run_fault, FLTTRACE);
977 sigaddset (run_fault, FLTILL);
978 sigaddset (run_fault, FLTPRIV);
979 sigaddset (run_fault, FLTBOUNDS);
980 sigaddset (run_fault, FLTIOVF);
981 sigaddset (run_fault, FLTIZDIV);
982 sigaddset (run_fault, FLTFPE);
983 /* Peter V will be changing this at some point. */
984 sigaddset (run_fault, FLTPAGE);
986 run.flags |= _DEBUG_RUN_ARM;
988 sigemptyset (&run.trace);
990 signal_to_pass = target_signal_to_host (signo);
994 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
995 signal_to_pass = target_signal_to_host (signo);
996 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
998 if (signal_to_pass != status.info.si_signo)
1000 SignalKill (nto_node (), PIDGET (inferior_ptid), 0,
1001 signal_to_pass, 0, 0);
1002 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1004 else /* Let it kill the program without telling us. */
1005 sigdelset (&run.trace, signal_to_pass);
1009 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1011 errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1014 perror (_("run error!\n"));
1020 procfs_mourn_inferior (struct target_ops *ops)
1022 if (!ptid_equal (inferior_ptid, null_ptid))
1024 SignalKill (nto_node (), PIDGET (inferior_ptid), 0, SIGKILL, 0, 0);
1027 inferior_ptid = null_ptid;
1028 init_thread_list ();
1029 unpush_target (&procfs_ops);
1030 generic_mourn_inferior ();
1033 /* This function breaks up an argument string into an argument
1034 vector suitable for passing to execvp().
1035 E.g., on "run a b c d" this routine would get as input
1036 the string "a b c d", and as output it would fill in argv with
1037 the four arguments "a", "b", "c", "d". The only additional
1038 functionality is simple quoting. The gdb command:
1040 will fill in argv with the three args "a", "b c d", "e". */
1042 breakup_args (char *scratch, char **argv)
1044 char *pp, *cp = scratch;
1049 /* Scan past leading separators. */
1051 while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1054 /* Break if at end of string. */
1062 quoting = strchr (cp, '"') ? 1 : 0;
1067 /* Scan for next arg separator. */
1070 cp = strchr (pp, '"');
1071 if ((cp == NULL) || (!quoting))
1072 cp = strchr (pp, ' ');
1074 cp = strchr (pp, '\t');
1076 cp = strchr (pp, '\n');
1078 /* No separators => end of string => break. */
1085 /* Replace the separator with a terminator. */
1089 /* Execv requires a null-terminated arg vector. */
1094 procfs_create_inferior (struct target_ops *ops, char *exec_file,
1095 char *allargs, char **env, int from_tty)
1097 struct inheritance inherit;
1101 const char *in = "", *out = "", *err = "";
1104 const char *inferior_io_terminal = get_inferior_io_terminal ();
1105 struct inferior *inf;
1107 argv = xmalloc (((strlen (allargs) + 1) / (unsigned) 2 + 2) *
1109 argv[0] = get_exec_file (1);
1113 argv[0] = exec_file;
1118 args = xstrdup (allargs);
1119 breakup_args (args, exec_file ? &argv[1] : &argv[0]);
1121 argv = nto_parse_redirection (argv, &in, &out, &err);
1123 fds[0] = STDIN_FILENO;
1124 fds[1] = STDOUT_FILENO;
1125 fds[2] = STDERR_FILENO;
1127 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1128 if the i/o is not also being specified via redirection. */
1129 if (inferior_io_terminal)
1132 in = inferior_io_terminal;
1134 out = inferior_io_terminal;
1136 err = inferior_io_terminal;
1141 fd = open (in, O_RDONLY);
1149 fd = open (out, O_WRONLY);
1157 fd = open (err, O_WRONLY);
1164 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1165 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1168 sigaddset (&set, SIGUSR1);
1169 sigprocmask (SIG_UNBLOCK, &set, NULL);
1171 memset (&inherit, 0, sizeof (inherit));
1173 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1175 inherit.nd = nto_node ();
1176 inherit.flags |= SPAWN_SETND;
1177 inherit.flags &= ~SPAWN_EXEC;
1179 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1180 inherit.pgroup = SPAWN_NEWPGROUP;
1181 pid = spawnp (argv[0], 3, fds, &inherit, argv,
1182 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1185 sigprocmask (SIG_BLOCK, &set, NULL);
1188 error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1189 safe_strerror (errno));
1191 if (fds[0] != STDIN_FILENO)
1193 if (fds[1] != STDOUT_FILENO)
1195 if (fds[2] != STDERR_FILENO)
1198 inferior_ptid = do_attach (pid_to_ptid (pid));
1199 procfs_find_new_threads (ops);
1201 inf = current_inferior ();
1202 inferior_appeared (inf, pid);
1203 inf->attach_flag = 0;
1205 flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */
1206 errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1209 /* FIXME: expected warning? */
1210 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1211 errn, strerror(errn) ); */
1214 target_terminal_init ();
1216 if (exec_bfd != NULL
1217 || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1218 solib_create_inferior_hook (0);
1222 procfs_stop (ptid_t ptid)
1224 devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1228 procfs_kill_inferior (struct target_ops *ops)
1230 target_mourn_inferior ();
1233 /* Store register REGNO, or all registers if REGNO == -1, from the contents
1236 procfs_prepare_to_store (struct regcache *regcache)
1240 /* Fill buf with regset and return devctl cmd to do the setting. Return
1241 -1 if we fail to get the regset. Store size of regset in regsize. */
1243 get_regset (int regset, char *buf, int bufsize, int *regsize)
1245 int dev_get, dev_set;
1248 case NTO_REG_GENERAL:
1249 dev_get = DCMD_PROC_GETGREG;
1250 dev_set = DCMD_PROC_SETGREG;
1254 dev_get = DCMD_PROC_GETFPREG;
1255 dev_set = DCMD_PROC_SETFPREG;
1259 dev_get = DCMD_PROC_GETALTREG;
1260 dev_set = DCMD_PROC_SETALTREG;
1263 case NTO_REG_SYSTEM:
1267 if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1274 procfs_store_registers (struct target_ops *ops,
1275 struct regcache *regcache, int regno)
1281 procfs_altreg altreg;
1285 int len, regset, regsize, dev_set, err;
1288 if (ptid_equal (inferior_ptid, null_ptid))
1290 procfs_set_thread (inferior_ptid);
1294 for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1296 dev_set = get_regset (regset, (char *) ®,
1297 sizeof (reg), ®size);
1301 if (nto_regset_fill (regcache, regset, (char *) ®) == -1)
1304 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1306 fprintf_unfiltered (gdb_stderr,
1307 "Warning unable to write regset %d: %s\n",
1308 regno, safe_strerror (err));
1313 regset = nto_regset_id (regno);
1317 dev_set = get_regset (regset, (char *) ®, sizeof (reg), ®size);
1321 len = nto_register_area (get_regcache_arch (regcache),
1322 regno, regset, &off);
1327 regcache_raw_collect (regcache, regno, (char *) ® + off);
1329 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1331 fprintf_unfiltered (gdb_stderr,
1332 "Warning unable to write regset %d: %s\n", regno,
1333 safe_strerror (err));
1338 notice_signals (void)
1342 for (signo = 1; signo < NSIG; signo++)
1344 if (signal_stop_state (target_signal_from_host (signo)) == 0
1345 && signal_print_state (target_signal_from_host (signo)) == 0
1346 && signal_pass_state (target_signal_from_host (signo)) == 1)
1347 sigdelset (&run.trace, signo);
1349 sigaddset (&run.trace, signo);
1353 /* When the user changes the state of gdb's signal handling via the
1354 "handle" command, this function gets called to see if any change
1355 in the /proc interface is required. It is also called internally
1356 by other /proc interface functions to initialize the state of
1357 the traced signal set. */
1359 procfs_notice_signals (ptid_t ptid)
1361 sigemptyset (&run.trace);
1365 static struct tidinfo *
1366 procfs_thread_info (pid_t pid, short tid)
1373 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
1375 static char buf[1024];
1377 struct tidinfo *tip;
1379 pid = ptid_get_pid (ptid);
1380 tid = ptid_get_tid (ptid);
1382 n = snprintf (buf, 1023, "process %d", pid);
1385 tip = procfs_thread_info (pid, tid);
1387 snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1394 init_procfs_ops (void)
1396 procfs_ops.to_shortname = "procfs";
1397 procfs_ops.to_longname = "QNX Neutrino procfs child process";
1399 "QNX Neutrino procfs child process (started by the \"run\" command).\n\
1400 target procfs <node>";
1401 procfs_ops.to_open = procfs_open;
1402 procfs_ops.to_attach = procfs_attach;
1403 procfs_ops.to_post_attach = procfs_post_attach;
1404 procfs_ops.to_detach = procfs_detach;
1405 procfs_ops.to_resume = procfs_resume;
1406 procfs_ops.to_wait = procfs_wait;
1407 procfs_ops.to_fetch_registers = procfs_fetch_registers;
1408 procfs_ops.to_store_registers = procfs_store_registers;
1409 procfs_ops.to_prepare_to_store = procfs_prepare_to_store;
1410 procfs_ops.deprecated_xfer_memory = procfs_xfer_memory;
1411 procfs_ops.to_files_info = procfs_files_info;
1412 procfs_ops.to_insert_breakpoint = procfs_insert_breakpoint;
1413 procfs_ops.to_remove_breakpoint = procfs_remove_breakpoint;
1414 procfs_ops.to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
1415 procfs_ops.to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
1416 procfs_ops.to_remove_hw_breakpoint = procfs_remove_breakpoint;
1417 procfs_ops.to_insert_watchpoint = procfs_insert_hw_watchpoint;
1418 procfs_ops.to_remove_watchpoint = procfs_remove_hw_watchpoint;
1419 procfs_ops.to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
1420 procfs_ops.to_terminal_init = terminal_init_inferior;
1421 procfs_ops.to_terminal_inferior = terminal_inferior;
1422 procfs_ops.to_terminal_ours_for_output = terminal_ours_for_output;
1423 procfs_ops.to_terminal_ours = terminal_ours;
1424 procfs_ops.to_terminal_info = child_terminal_info;
1425 procfs_ops.to_kill = procfs_kill_inferior;
1426 procfs_ops.to_create_inferior = procfs_create_inferior;
1427 procfs_ops.to_mourn_inferior = procfs_mourn_inferior;
1428 procfs_ops.to_can_run = procfs_can_run;
1429 procfs_ops.to_notice_signals = procfs_notice_signals;
1430 procfs_ops.to_thread_alive = procfs_thread_alive;
1431 procfs_ops.to_find_new_threads = procfs_find_new_threads;
1432 procfs_ops.to_pid_to_str = procfs_pid_to_str;
1433 procfs_ops.to_stop = procfs_stop;
1434 procfs_ops.to_stratum = process_stratum;
1435 procfs_ops.to_has_all_memory = default_child_has_all_memory;
1436 procfs_ops.to_has_memory = default_child_has_memory;
1437 procfs_ops.to_has_stack = default_child_has_stack;
1438 procfs_ops.to_has_registers = default_child_has_registers;
1439 procfs_ops.to_has_execution = default_child_has_execution;
1440 procfs_ops.to_magic = OPS_MAGIC;
1441 procfs_ops.to_have_continuable_watchpoint = 1;
1442 procfs_ops.to_extra_thread_info = nto_extra_thread_info;
1445 #define OSTYPE_NTO 1
1448 _initialize_procfs (void)
1453 add_target (&procfs_ops);
1455 /* We use SIGUSR1 to gain control after we block waiting for a process.
1456 We use sigwaitevent to wait. */
1458 sigaddset (&set, SIGUSR1);
1459 sigprocmask (SIG_BLOCK, &set, NULL);
1461 /* Set up trace and fault sets, as gdb expects them. */
1462 sigemptyset (&run.trace);
1464 /* Stuff some information. */
1465 nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1466 nto_cpuinfo_valid = 1;
1468 add_info ("pidlist", procfs_pidlist, _("pidlist"));
1469 add_info ("meminfo", procfs_meminfo, _("memory information"));
1471 nto_is_nto_target = procfs_is_nto_target;
1476 procfs_hw_watchpoint (int addr, int len, int type)
1483 brk.type = _DEBUG_BREAK_RD;
1485 case 2: /* Read/Write. */
1486 brk.type = _DEBUG_BREAK_RW;
1488 default: /* Modify. */
1489 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1490 brk.type = _DEBUG_BREAK_RW;
1492 brk.type |= _DEBUG_BREAK_HW; /* Always ask for HW. */
1496 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1499 perror (_("Failed to set hardware watchpoint"));
1506 procfs_can_use_hw_breakpoint (int type, int cnt, int othertype)
1512 procfs_remove_hw_watchpoint (CORE_ADDR addr, int len, int type,
1513 struct expression *cond)
1515 return procfs_hw_watchpoint (addr, -1, type);
1519 procfs_insert_hw_watchpoint (CORE_ADDR addr, int len, int type,
1520 struct expression *cond)
1522 return procfs_hw_watchpoint (addr, len, type);
1526 procfs_stopped_by_watchpoint (void)