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-2018 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>
39 #include "gdbthread.h"
44 #include "inf-child.h"
45 #include "common/filestuff.h"
46 #include "common/scoped_fd.h"
49 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
50 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
54 static sighandler_t ofunc;
56 static procfs_run run;
58 /* Create the "native" and "procfs" targets. */
60 struct nto_procfs_target : public inf_child_target
62 void open (const char *arg, int from_tty) override;
64 void attach (const char *, int) override = 0;
66 void post_attach (int);
68 void detach (inferior *, int) override;
70 void resume (ptid_t, int, enum gdb_signal) override;
72 ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
74 void fetch_registers (struct regcache *, int) override;
75 void store_registers (struct regcache *, int) override;
77 enum target_xfer_status xfer_partial (enum target_object object,
80 const gdb_byte *writebuf,
81 ULONGEST offset, ULONGEST len,
82 ULONGEST *xfered_len) override;
84 void files_info () override;
86 int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override;
88 int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
89 enum remove_bp_reason) override;
91 int can_use_hw_breakpoint (enum bptype, int, int) override;
93 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
95 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
97 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
98 struct expression *) override;
100 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
101 struct expression *) override;
103 bool stopped_by_watchpoint () override;
105 void kill () override;
107 void create_inferior (const char *, const std::string &,
108 char **, int) override;
110 void mourn_inferior () override;
112 void pass_signals (int, unsigned char *) override;
114 bool thread_alive (ptid_t ptid) override;
116 void update_thread_list () override;
118 const char *pid_to_str (ptid_t) override;
120 void interrupt () override;
122 bool have_continuable_watchpoint ()
125 const char *extra_thread_info (struct thread_info *) override;
127 char *pid_to_exec_file (int pid) override;
130 /* For "target native". */
132 static const target_info nto_native_target_info = {
134 N_("QNX Neutrino local process"),
135 N_("QNX Neutrino local process (started by the \"run\" command).")
138 class nto_procfs_target_native final : public nto_procfs_target
140 const target_info &info () const override
141 { return nto_native_target_info; }
144 /* For "target procfs <node>". */
146 static const target_info nto_procfs_target_info = {
148 N_("QNX Neutrino local or remote process"),
149 N_("QNX Neutrino process. target procfs <node>")
152 struct nto_procfs_target_procfs final : public nto_procfs_target
154 const target_info &info () const override
155 { return nto_procfs_target_info; }
158 static ptid_t do_attach (ptid_t ptid);
160 /* These two globals are only ever set in procfs_open_1, but are
161 referenced elsewhere. 'nto_procfs_node' is a flag used to say
162 whether we are local, or we should get the current node descriptor
163 for the remote QNX node. */
164 static char *nodestr;
165 static unsigned nto_procfs_node = ND_LOCAL_NODE;
167 /* Return the current QNX Node, or error out. This is a simple
168 wrapper for the netmgr_strtond() function. The reason this
169 is required is because QNX node descriptors are transient so
170 we have to re-acquire them every time. */
176 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0
178 return ND_LOCAL_NODE;
180 node = netmgr_strtond (nodestr, 0);
182 error (_("Lost the QNX node. Debug session probably over."));
187 static enum gdb_osabi
188 procfs_is_nto_target (bfd *abfd)
190 return GDB_OSABI_QNXNTO;
193 /* This is called when we call 'target native' or 'target procfs
194 <arg>' from the (gdb) prompt. For QNX6 (nto), the only valid arg
195 will be a QNX node string, eg: "/net/some_node". If arg is not a
196 valid QNX node, we will default to local. */
198 nto_procfs_target::open (const char *arg, int from_tty)
203 procfs_sysinfo *sysinfo;
204 char nto_procfs_path[PATH_MAX];
206 /* Offer to kill previous inferiors before opening this target. */
207 target_preopen (from_tty);
209 nto_is_nto_target = procfs_is_nto_target;
211 /* Set the default node used for spawning to this one,
212 and only override it if there is a valid arg. */
217 nto_procfs_node = ND_LOCAL_NODE;
218 nodestr = (arg != NULL) ? xstrdup (arg) : NULL;
224 nto_procfs_node = netmgr_strtond (nodestr, &endstr);
225 if (nto_procfs_node == -1)
227 if (errno == ENOTSUP)
228 printf_filtered ("QNX Net Manager not found.\n");
229 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr,
230 errno, safe_strerror (errno));
233 nto_procfs_node = ND_LOCAL_NODE;
237 if (*(endstr - 1) == '/')
243 snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s",
244 (nodestr != NULL) ? nodestr : "", "/proc");
246 scoped_fd fd (open (nto_procfs_path, O_RDONLY));
249 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
250 safe_strerror (errno));
251 error (_("Invalid procfs arg"));
254 sysinfo = (void *) buffer;
255 if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
257 printf_filtered ("Error getting size: %d (%s)\n", errno,
258 safe_strerror (errno));
259 error (_("Devctl failed."));
263 total_size = sysinfo->total_size;
264 sysinfo = alloca (total_size);
267 printf_filtered ("Memory error: %d (%s)\n", errno,
268 safe_strerror (errno));
269 error (_("alloca failed."));
273 if (devctl (fd.get (), DCMD_PROC_SYSINFO, sysinfo, total_size, 0)
276 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
277 safe_strerror (errno));
278 error (_("Devctl failed."));
283 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
284 (target_gdbarch ())->arch_name))
285 error (_("Invalid target CPU."));
290 inf_child_target::open (arg, from_tty);
291 printf_filtered ("Debugging using %s\n", nto_procfs_path);
295 procfs_set_thread (ptid_t ptid)
299 tid = ptid_get_tid (ptid);
300 devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
303 /* Return true if the thread TH is still alive. */
306 nto_procfs_target::thread_alive (ptid_t ptid)
310 procfs_status status;
313 tid = ptid_get_tid (ptid);
316 if (kill (pid, 0) == -1)
320 if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS,
321 &status, sizeof (status), 0)) != EOK)
324 /* Thread is alive or dead but not yet joined,
325 or dead and there is an alive (or dead unjoined) thread with
328 If the tid is not the same as requested, requested tid is dead. */
329 return (status.tid == tid) && (status.state != STATE_DEAD);
333 update_thread_private_data_name (struct thread_info *new_thread,
336 nto_thread_info *pti = get_nto_thread_info (new_thread);
338 gdb_assert (newname != NULL);
339 gdb_assert (new_thread != NULL);
343 pti = new nto_thread_info;
344 new_thread->priv.reset (pti);
351 update_thread_private_data (struct thread_info *new_thread,
352 pthread_t tid, int state, int flags)
355 struct _thread_name *tn;
356 procfs_threadctl tctl;
358 #if _NTO_VERSION > 630
359 gdb_assert (new_thread != NULL);
361 if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo,
362 sizeof(pidinfo), 0) != EOK)
365 memset (&tctl, 0, sizeof (tctl));
366 tctl.cmd = _NTO_TCTL_NAME;
367 tn = (struct _thread_name *) (&tctl.data);
369 /* Fetch name for the given thread. */
371 tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn);
372 tn->new_name_len = -1; /* Getting, not setting. */
373 if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK)
374 tn->name_buf[0] = '\0';
376 tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0';
378 update_thread_private_data_name (new_thread, tn->name_buf);
380 nto_thread_info *pti = get_nto_thread_info (new_thread);
384 #endif /* _NTO_VERSION */
388 nto_procfs_target::update_thread_list ()
390 procfs_status status;
394 struct thread_info *new_thread;
401 pid = inferior_ptid.pid ();
405 for (tid = 1;; ++tid)
407 if (status.tid == tid
408 && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
411 if (status.tid != tid)
412 /* The reason why this would not be equal is that devctl might have
413 returned different tid, meaning the requested tid no longer exists
414 (e.g. thread exited). */
416 ptid = ptid_t (pid, 0, tid);
417 new_thread = find_thread_ptid (ptid);
419 new_thread = add_thread (ptid);
420 update_thread_private_data (new_thread, tid, status.state, 0);
427 procfs_pidlist (const char *args, int from_tty)
429 struct dirent *dirp = NULL;
431 procfs_info *pidinfo = NULL;
432 procfs_debuginfo *info = NULL;
433 procfs_status *status = NULL;
434 pid_t num_threads = 0;
437 char procfs_dir[PATH_MAX];
439 snprintf (procfs_dir, sizeof (procfs_dir), "%s%s",
440 (nodestr != NULL) ? nodestr : "", "/proc");
442 gdb_dir_up dp (opendir (procfs_dir));
445 fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
446 procfs_dir, errno, safe_strerror (errno));
450 /* Start scan at first pid. */
451 rewinddir (dp.get ());
455 /* Get the right pid and procfs path for the pid. */
458 dirp = readdir (dp.get ());
461 snprintf (buf, sizeof (buf), "%s%s/%s/as",
462 (nodestr != NULL) ? nodestr : "",
463 "/proc", dirp->d_name);
464 pid = atoi (dirp->d_name);
468 /* Open the procfs path. */
469 scoped_fd fd (open (buf, O_RDONLY));
472 fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
473 buf, errno, safe_strerror (errno));
477 pidinfo = (procfs_info *) buf;
478 if (devctl (fd.get (), DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
480 fprintf_unfiltered (gdb_stderr,
481 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
482 errno, safe_strerror (errno));
485 num_threads = pidinfo->num_threads;
487 info = (procfs_debuginfo *) buf;
488 if (devctl (fd.get (), DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0)
490 strcpy (name, "unavailable");
492 strcpy (name, info->path);
494 /* Collect state info on all the threads. */
495 status = (procfs_status *) buf;
496 for (status->tid = 1; status->tid <= num_threads; status->tid++)
499 = devctl (fd.get (), DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0);
500 printf_filtered ("%s - %d", name, pid);
501 if (err == EOK && status->tid != 0)
502 printf_filtered ("/%d\n", status->tid);
505 printf_filtered ("\n");
510 while (dirp != NULL);
514 procfs_meminfo (const char *args, int from_tty)
516 procfs_mapinfo *mapinfos = NULL;
517 static int num_mapinfos = 0;
518 procfs_mapinfo *mapinfo_p, *mapinfo_p2;
519 int flags = ~0, err, num, i, j;
523 procfs_debuginfo info;
524 char buff[_POSIX_PATH_MAX];
532 unsigned debug_vaddr;
533 unsigned long long offset;
538 unsigned long long ino;
545 /* Get the number of map entrys. */
546 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
549 printf ("failed devctl num mapinfos - %d (%s)\n", err,
550 safe_strerror (err));
554 mapinfos = XNEWVEC (procfs_mapinfo, num);
557 mapinfo_p = mapinfos;
559 /* Fill the map entrys. */
560 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
561 * sizeof (procfs_mapinfo), &num);
564 printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
569 num = std::min (num, num_mapinfos);
571 /* Run through the list of mapinfos, and store the data and text info
572 so we can print it at the bottom of the loop. */
573 for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
575 if (!(mapinfo_p->flags & flags))
578 if (mapinfo_p->ino == 0) /* Already visited. */
581 map.info.vaddr = mapinfo_p->vaddr;
583 err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
587 memset (&printme, 0, sizeof printme);
588 printme.dev = mapinfo_p->dev;
589 printme.ino = mapinfo_p->ino;
590 printme.text.addr = mapinfo_p->vaddr;
591 printme.text.size = mapinfo_p->size;
592 printme.text.flags = mapinfo_p->flags;
593 printme.text.offset = mapinfo_p->offset;
594 printme.text.debug_vaddr = map.info.vaddr;
595 strcpy (printme.name, map.info.path);
597 /* Check for matching data. */
598 for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
600 if (mapinfo_p2->vaddr != mapinfo_p->vaddr
601 && mapinfo_p2->ino == mapinfo_p->ino
602 && mapinfo_p2->dev == mapinfo_p->dev)
604 map.info.vaddr = mapinfo_p2->vaddr;
606 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
610 if (strcmp (map.info.path, printme.name))
613 /* Lower debug_vaddr is always text, if nessessary, swap. */
614 if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
616 memcpy (&(printme.data), &(printme.text),
617 sizeof (printme.data));
618 printme.text.addr = mapinfo_p2->vaddr;
619 printme.text.size = mapinfo_p2->size;
620 printme.text.flags = mapinfo_p2->flags;
621 printme.text.offset = mapinfo_p2->offset;
622 printme.text.debug_vaddr = map.info.vaddr;
626 printme.data.addr = mapinfo_p2->vaddr;
627 printme.data.size = mapinfo_p2->size;
628 printme.data.flags = mapinfo_p2->flags;
629 printme.data.offset = mapinfo_p2->offset;
630 printme.data.debug_vaddr = map.info.vaddr;
637 printf_filtered ("%s\n", printme.name);
638 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
640 printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
641 printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
642 printf_filtered ("\t\toffset=%s\n", phex (printme.text.offset, 8));
643 if (printme.data.size)
645 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
647 printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
648 printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
649 printf_filtered ("\t\toffset=%s\n", phex (printme.data.offset, 8));
651 printf_filtered ("\tdev=0x%x\n", printme.dev);
652 printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
658 /* Print status information about what we're accessing. */
660 nto_procfs_target::files_info ()
662 struct inferior *inf = current_inferior ();
664 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
665 inf->attach_flag ? "attached" : "child",
666 target_pid_to_str (inferior_ptid),
667 (nodestr != NULL) ? nodestr : "local node");
670 /* Target to_pid_to_exec_file implementation. */
673 nto_procfs_target::pid_to_exec_file (const int pid)
676 static char proc_path[PATH_MAX];
679 /* Read exe file name. */
680 snprintf (proc_path, sizeof (proc_path), "%s/proc/%d/exefile",
681 (nodestr != NULL) ? nodestr : "", pid);
682 proc_fd = open (proc_path, O_RDONLY);
686 rd = read (proc_fd, proc_path, sizeof (proc_path) - 1);
693 proc_path[rd] = '\0';
697 /* Attach to process PID, then initialize for debugging it. */
699 nto_procfs_target::attach (const char *args, int from_tty)
703 struct inferior *inf;
705 pid = parse_pid_to_attach (args);
707 if (pid == getpid ())
708 error (_("Attaching GDB to itself is not a good idea..."));
712 exec_file = (char *) get_exec_file (0);
715 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
716 target_pid_to_str (ptid_t (pid)));
718 printf_unfiltered ("Attaching to %s\n",
719 target_pid_to_str (ptid_t (pid)));
721 gdb_flush (gdb_stdout);
723 inferior_ptid = do_attach (ptid_t (pid));
724 inf = current_inferior ();
725 inferior_appeared (inf, pid);
726 inf->attach_flag = 1;
728 if (!target_is_pushed (ops))
731 procfs_update_thread_list (ops);
735 nto_procfs_target::post_attach (pid_t pid)
738 solib_create_inferior_hook (0);
742 do_attach (ptid_t ptid)
744 procfs_status status;
745 struct sigevent event;
748 snprintf (path, PATH_MAX - 1, "%s%s/%d/as",
749 (nodestr != NULL) ? nodestr : "", "/proc", ptid.pid ());
750 ctl_fd = open (path, O_RDWR);
752 error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
753 safe_strerror (errno));
754 if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
755 error (_("Couldn't stop process"));
757 /* Define a sigevent for process stopped notification. */
758 event.sigev_notify = SIGEV_SIGNAL_THREAD;
759 event.sigev_signo = SIGUSR1;
760 event.sigev_code = 0;
761 event.sigev_value.sival_ptr = NULL;
762 event.sigev_priority = -1;
763 devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
765 if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
766 && status.flags & _DEBUG_FLAG_STOPPED)
767 SignalKill (nto_node (), ptid.pid (), 0, SIGCONT, 0, 0);
768 nto_init_solib_absolute_prefix ();
769 return ptid_t (ptid.pid (), 0, status.tid);
772 /* Ask the user what to do when an interrupt is received. */
774 interrupt_query (void)
776 if (query (_("Interrupted while waiting for the program.\n\
777 Give up (and stop debugging it)? ")))
779 target_mourn_inferior (inferior_ptid);
784 /* The user typed ^C twice. */
786 nto_handle_sigint_twice (int signo)
788 signal (signo, ofunc);
790 signal (signo, nto_handle_sigint_twice);
794 nto_handle_sigint (int signo)
796 /* If this doesn't work, try more severe steps. */
797 signal (signo, nto_handle_sigint_twice);
803 nto_procfs_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
808 procfs_status status;
809 static int exit_signo = 0; /* To track signals that cause termination. */
811 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
813 if (ptid_equal (inferior_ptid, null_ptid))
815 ourstatus->kind = TARGET_WAITKIND_STOPPED;
816 ourstatus->value.sig = GDB_SIGNAL_0;
822 sigaddset (&set, SIGUSR1);
824 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
825 while (!(status.flags & _DEBUG_FLAG_ISTOP))
827 ofunc = signal (SIGINT, nto_handle_sigint);
828 sigwaitinfo (&set, &info);
829 signal (SIGINT, ofunc);
830 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
833 nto_inferior_data (NULL)->stopped_flags = status.flags;
834 nto_inferior_data (NULL)->stopped_pc = status.ip;
836 if (status.flags & _DEBUG_FLAG_SSTEP)
838 ourstatus->kind = TARGET_WAITKIND_STOPPED;
839 ourstatus->value.sig = GDB_SIGNAL_TRAP;
841 /* Was it a breakpoint? */
842 else if (status.flags & _DEBUG_FLAG_TRACE)
844 ourstatus->kind = TARGET_WAITKIND_STOPPED;
845 ourstatus->value.sig = GDB_SIGNAL_TRAP;
847 else if (status.flags & _DEBUG_FLAG_ISTOP)
851 case _DEBUG_WHY_SIGNALLED:
852 ourstatus->kind = TARGET_WAITKIND_STOPPED;
853 ourstatus->value.sig =
854 gdb_signal_from_host (status.info.si_signo);
857 case _DEBUG_WHY_FAULTED:
858 ourstatus->kind = TARGET_WAITKIND_STOPPED;
859 if (status.info.si_signo == SIGTRAP)
861 ourstatus->value.sig = 0;
866 ourstatus->value.sig =
867 gdb_signal_from_host (status.info.si_signo);
868 exit_signo = ourstatus->value.sig;
872 case _DEBUG_WHY_TERMINATED:
876 waitpid (inferior_ptid.pid (), &waitval, WNOHANG);
879 /* Abnormal death. */
880 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
881 ourstatus->value.sig = exit_signo;
886 ourstatus->kind = TARGET_WAITKIND_EXITED;
887 ourstatus->value.integer = WEXITSTATUS (waitval);
893 case _DEBUG_WHY_REQUESTED:
894 /* We are assuming a requested stop is due to a SIGINT. */
895 ourstatus->kind = TARGET_WAITKIND_STOPPED;
896 ourstatus->value.sig = GDB_SIGNAL_INT;
902 return ptid_t (status.pid, 0, status.tid);
905 /* Read the current values of the inferior's registers, both the
906 general register set and floating point registers (if supported)
907 and update gdb's idea of their current values. */
909 nto_procfs_target::fetch_registers (struct regcache *regcache, int regno)
915 procfs_altreg altreg;
920 procfs_set_thread (regcache->ptid ());
921 if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK)
922 nto_supply_gregset (regcache, (char *) ®.greg);
923 if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size)
925 nto_supply_fpregset (regcache, (char *) ®.fpreg);
926 if (devctl (ctl_fd, DCMD_PROC_GETALTREG, ®, sizeof (reg), ®size)
928 nto_supply_altregset (regcache, (char *) ®.altreg);
931 /* Helper for procfs_xfer_partial that handles memory transfers.
932 Arguments are like target_xfer_partial. */
934 static enum target_xfer_status
935 procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
936 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
940 if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr)
941 return TARGET_XFER_E_IO;
943 if (writebuf != NULL)
944 nbytes = write (ctl_fd, writebuf, len);
946 nbytes = read (ctl_fd, readbuf, len);
948 return TARGET_XFER_E_IO;
949 *xfered_len = nbytes;
950 return TARGET_XFER_OK;
953 /* Target to_xfer_partial implementation. */
955 enum target_xfer_status
956 nto_procfs_target::xfer_partial (enum target_object object,
957 const char *annex, gdb_byte *readbuf,
958 const gdb_byte *writebuf, ULONGEST offset,
959 ULONGEST len, ULONGEST *xfered_len)
963 case TARGET_OBJECT_MEMORY:
964 return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
965 case TARGET_OBJECT_AUXV:
969 CORE_ADDR initial_stack;
970 debug_process_t procinfo;
971 /* For 32-bit architecture, size of auxv_t is 8 bytes. */
972 const unsigned int sizeof_auxv_t = sizeof (auxv_t);
973 const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t;
975 gdb_byte *const tempbuf = alloca (sizeof_tempbuf);
978 return TARGET_XFER_E_IO;
980 err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo,
983 return TARGET_XFER_E_IO;
985 initial_stack = procinfo.initial_stack;
987 /* procfs is always 'self-hosted', no byte-order manipulation. */
988 tempread = nto_read_auxv_from_initial_stack (initial_stack, tempbuf,
991 tempread = std::min (tempread, len) - offset;
992 memcpy (readbuf, tempbuf + offset, tempread);
993 *xfered_len = tempread;
994 return tempread ? TARGET_XFER_OK : TARGET_XFER_EOF;
998 return this->beneath ()->xfer_partial (object, annex,
999 readbuf, writebuf, offset, len,
1004 /* Take a program previously attached to and detaches it.
1005 The program resumes execution and will no longer stop
1006 on signals, etc. We'd better not have left any breakpoints
1007 in the program or it'll die when it hits one. */
1009 nto_procfs_target::detach (inferior *inf, int from_tty)
1013 target_announce_detach ();
1016 SignalKill (nto_node (), inferior_ptid.pid (), 0, 0, 0, 0);
1021 pid = inferior_ptid.pid ();
1022 inferior_ptid = null_ptid;
1023 detach_inferior (pid);
1024 init_thread_list ();
1025 inf_child_maybe_unpush_target (ops);
1029 procfs_breakpoint (CORE_ADDR addr, int type, int size)
1036 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1043 nto_procfs_target::insert_breakpoint (struct gdbarch *gdbarch,
1044 struct bp_target_info *bp_tgt)
1046 bp_tgt->placed_address = bp_tgt->reqstd_address;
1047 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
1051 nto_procfs_target::remove_breakpoint (struct gdbarch *gdbarch,
1052 struct bp_target_info *bp_tgt,
1053 enum remove_bp_reason reason)
1055 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
1059 nto_procfs_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
1060 struct bp_target_info *bp_tgt)
1062 bp_tgt->placed_address = bp_tgt->reqstd_address;
1063 return procfs_breakpoint (bp_tgt->placed_address,
1064 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
1068 nto_procfs_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
1069 struct bp_target_info *bp_tgt)
1071 return procfs_breakpoint (bp_tgt->placed_address,
1072 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
1076 nto_procfs_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
1079 procfs_status status;
1080 sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
1082 if (ptid_equal (inferior_ptid, null_ptid))
1085 procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
1088 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
1090 run.flags |= _DEBUG_RUN_STEP;
1092 sigemptyset (run_fault);
1093 sigaddset (run_fault, FLTBPT);
1094 sigaddset (run_fault, FLTTRACE);
1095 sigaddset (run_fault, FLTILL);
1096 sigaddset (run_fault, FLTPRIV);
1097 sigaddset (run_fault, FLTBOUNDS);
1098 sigaddset (run_fault, FLTIOVF);
1099 sigaddset (run_fault, FLTIZDIV);
1100 sigaddset (run_fault, FLTFPE);
1101 /* Peter V will be changing this at some point. */
1102 sigaddset (run_fault, FLTPAGE);
1104 run.flags |= _DEBUG_RUN_ARM;
1106 signal_to_pass = gdb_signal_to_host (signo);
1110 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
1111 signal_to_pass = gdb_signal_to_host (signo);
1112 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
1114 if (signal_to_pass != status.info.si_signo)
1116 SignalKill (nto_node (), inferior_ptid.pid (), 0,
1117 signal_to_pass, 0, 0);
1118 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1120 else /* Let it kill the program without telling us. */
1121 sigdelset (&run.trace, signal_to_pass);
1125 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1127 errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1130 perror (_("run error!\n"));
1136 nto_procfs_target::mourn_inferior ()
1138 if (!ptid_equal (inferior_ptid, null_ptid))
1140 SignalKill (nto_node (), inferior_ptid.pid (), 0, SIGKILL, 0, 0);
1143 inferior_ptid = null_ptid;
1144 init_thread_list ();
1145 inf_child_mourn_inferior (ops);
1148 /* This function breaks up an argument string into an argument
1149 vector suitable for passing to execvp().
1150 E.g., on "run a b c d" this routine would get as input
1151 the string "a b c d", and as output it would fill in argv with
1152 the four arguments "a", "b", "c", "d". The only additional
1153 functionality is simple quoting. The gdb command:
1155 will fill in argv with the three args "a", "b c d", "e". */
1157 breakup_args (char *scratch, char **argv)
1159 char *pp, *cp = scratch;
1164 /* Scan past leading separators. */
1166 while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1169 /* Break if at end of string. */
1177 quoting = strchr (cp, '"') ? 1 : 0;
1182 /* Scan for next arg separator. */
1185 cp = strchr (pp, '"');
1186 if ((cp == NULL) || (!quoting))
1187 cp = strchr (pp, ' ');
1189 cp = strchr (pp, '\t');
1191 cp = strchr (pp, '\n');
1193 /* No separators => end of string => break. */
1200 /* Replace the separator with a terminator. */
1204 /* Execv requires a null-terminated arg vector. */
1209 nto_procfs_target::create_inferior (const char *exec_file,
1210 const std::string &allargs,
1211 char **env, int from_tty)
1213 struct inheritance inherit;
1217 const char *in = "", *out = "", *err = "";
1220 const char *inferior_io_terminal = get_inferior_io_terminal ();
1221 struct inferior *inf;
1223 argv = xmalloc ((allargs.size () / (unsigned) 2 + 2) *
1225 argv[0] = get_exec_file (1);
1229 argv[0] = exec_file;
1234 args = xstrdup (allargs.c_str ());
1235 breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]);
1237 argv = nto_parse_redirection (argv, &in, &out, &err);
1239 fds[0] = STDIN_FILENO;
1240 fds[1] = STDOUT_FILENO;
1241 fds[2] = STDERR_FILENO;
1243 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1244 if the i/o is not also being specified via redirection. */
1245 if (inferior_io_terminal)
1248 in = inferior_io_terminal;
1250 out = inferior_io_terminal;
1252 err = inferior_io_terminal;
1257 fd = open (in, O_RDONLY);
1265 fd = open (out, O_WRONLY);
1273 fd = open (err, O_WRONLY);
1280 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1281 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1284 sigaddset (&set, SIGUSR1);
1285 sigprocmask (SIG_UNBLOCK, &set, NULL);
1287 memset (&inherit, 0, sizeof (inherit));
1289 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1291 inherit.nd = nto_node ();
1292 inherit.flags |= SPAWN_SETND;
1293 inherit.flags &= ~SPAWN_EXEC;
1295 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1296 inherit.pgroup = SPAWN_NEWPGROUP;
1297 pid = spawnp (argv[0], 3, fds, &inherit, argv,
1298 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1301 sigprocmask (SIG_BLOCK, &set, NULL);
1304 error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1305 safe_strerror (errno));
1307 if (fds[0] != STDIN_FILENO)
1309 if (fds[1] != STDOUT_FILENO)
1311 if (fds[2] != STDERR_FILENO)
1314 inferior_ptid = do_attach (ptid_t (pid));
1315 procfs_update_thread_list (ops);
1317 inf = current_inferior ();
1318 inferior_appeared (inf, pid);
1319 inf->attach_flag = 0;
1321 flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */
1322 errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1325 /* FIXME: expected warning? */
1326 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1327 errn, strerror(errn) ); */
1329 if (!target_is_pushed (ops))
1331 target_terminal::init ();
1333 if (exec_bfd != NULL
1334 || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1335 solib_create_inferior_hook (0);
1339 nto_procfs_target::interrupt ()
1341 devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1345 nto_procfs_target::kill ()
1347 target_mourn_inferior (inferior_ptid);
1350 /* Fill buf with regset and return devctl cmd to do the setting. Return
1351 -1 if we fail to get the regset. Store size of regset in regsize. */
1353 get_regset (int regset, char *buf, int bufsize, int *regsize)
1355 int dev_get, dev_set;
1358 case NTO_REG_GENERAL:
1359 dev_get = DCMD_PROC_GETGREG;
1360 dev_set = DCMD_PROC_SETGREG;
1364 dev_get = DCMD_PROC_GETFPREG;
1365 dev_set = DCMD_PROC_SETFPREG;
1369 dev_get = DCMD_PROC_GETALTREG;
1370 dev_set = DCMD_PROC_SETALTREG;
1373 case NTO_REG_SYSTEM:
1377 if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1384 nto_procfs_target::store_registers (struct regcache *regcache, int regno)
1390 procfs_altreg altreg;
1394 int len, regset, regsize, dev_set, err;
1396 ptid_t ptid = regcache->ptid ();
1398 if (ptid_equal (ptid, null_ptid))
1400 procfs_set_thread (ptid);
1404 for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1406 dev_set = get_regset (regset, (char *) ®,
1407 sizeof (reg), ®size);
1411 if (nto_regset_fill (regcache, regset, (char *) ®) == -1)
1414 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1416 fprintf_unfiltered (gdb_stderr,
1417 "Warning unable to write regset %d: %s\n",
1418 regno, safe_strerror (err));
1423 regset = nto_regset_id (regno);
1427 dev_set = get_regset (regset, (char *) ®, sizeof (reg), ®size);
1431 len = nto_register_area (regcache->arch (),
1432 regno, regset, &off);
1437 regcache->raw_collect (regno, (char *) ® + off);
1439 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1441 fprintf_unfiltered (gdb_stderr,
1442 "Warning unable to write regset %d: %s\n", regno,
1443 safe_strerror (err));
1447 /* Set list of signals to be handled in the target. */
1450 nto_procfs_target::pass_signals (int numsigs, unsigned char *pass_signals)
1454 sigfillset (&run.trace);
1456 for (signo = 1; signo < NSIG; signo++)
1458 int target_signo = gdb_signal_from_host (signo);
1459 if (target_signo < numsigs && pass_signals[target_signo])
1460 sigdelset (&run.trace, signo);
1465 nto_procfs_target::pid_to_str (ptid_t ptid)
1467 static char buf[1024];
1469 struct tidinfo *tip;
1472 tid = ptid_get_tid (ptid);
1474 n = snprintf (buf, 1023, "process %d", pid);
1477 tip = procfs_thread_info (pid, tid);
1479 snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1485 /* to_can_run implementation for "target procfs". Note this really
1486 means "can this target be the default run target", which there can
1487 be only one, and we make it be "target native" like other ports.
1488 "target procfs <node>" wouldn't make sense as default run target, as
1492 nto_procfs_target::can_run ()
1497 /* "target procfs". */
1498 static nto_procfs_target_procfs nto_procfs_ops;
1500 /* "target native". */
1501 static nto_procfs_target_native nto_native_ops;
1503 /* Create the "native" and "procfs" targets. */
1506 init_procfs_targets (void)
1508 /* Register "target native". This is the default run target. */
1509 add_target (nto_native_target_info, inf_child_open_target);
1510 set_native_target (&nto_native_ops);
1512 /* Register "target procfs <node>". */
1513 add_target (nto_procfs_target_info, inf_child_open_target);
1516 #define OSTYPE_NTO 1
1519 _initialize_procfs (void)
1523 init_procfs_targets ();
1525 /* We use SIGUSR1 to gain control after we block waiting for a process.
1526 We use sigwaitevent to wait. */
1528 sigaddset (&set, SIGUSR1);
1529 sigprocmask (SIG_BLOCK, &set, NULL);
1531 /* Initially, make sure all signals are reported. */
1532 sigfillset (&run.trace);
1534 /* Stuff some information. */
1535 nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1536 nto_cpuinfo_valid = 1;
1538 add_info ("pidlist", procfs_pidlist, _("pidlist"));
1539 add_info ("meminfo", procfs_meminfo, _("memory information"));
1541 nto_is_nto_target = procfs_is_nto_target;
1546 procfs_hw_watchpoint (int addr, int len, enum target_hw_bp_type type)
1553 brk.type = _DEBUG_BREAK_RD;
1556 brk.type = _DEBUG_BREAK_RW;
1558 default: /* Modify. */
1559 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1560 brk.type = _DEBUG_BREAK_RW;
1562 brk.type |= _DEBUG_BREAK_HW; /* Always ask for HW. */
1566 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1569 perror (_("Failed to set hardware watchpoint"));
1576 nto_procfs_target::can_use_hw_breakpoint (enum bptype type,
1577 int cnt, int othertype)
1583 nto_procfs_target::remove_hw_watchpoint (CORE_ADDR addr, int len,
1584 enum target_hw_bp_type type,
1585 struct expression *cond)
1587 return procfs_hw_watchpoint (addr, -1, type);
1591 nto_procfs_target::insert_hw_watchpoint (CORE_ADDR addr, int len,
1592 enum target_hw_bp_type type,
1593 struct expression *cond)
1595 return procfs_hw_watchpoint (addr, len, type);
1599 nto_procfs_target::stopped_by_watchpoint ()
1601 /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are
1602 stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode;
1603 future gdb versions will likely run in 'non-stop' mode in which case
1604 we will have to store/examine statuses per thread in question.
1605 Until then, this will work fine. */
1607 struct inferior *inf = current_inferior ();
1608 struct nto_inferior_data *inf_data;
1610 gdb_assert (inf != NULL);
1612 inf_data = nto_inferior_data (inf);
1614 return inf_data->stopped_flags
1615 & (_DEBUG_FLAG_TRACE_RD
1616 | _DEBUG_FLAG_TRACE_WR
1617 | _DEBUG_FLAG_TRACE_MODIFY);