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);
314 pid = ptid_get_pid (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 = ptid_get_pid (inferior_ptid);
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_build (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 do_closedir_cleanup (void *dir)
433 procfs_pidlist (const char *args, int from_tty)
436 struct dirent *dirp = NULL;
438 procfs_info *pidinfo = NULL;
439 procfs_debuginfo *info = NULL;
440 procfs_status *status = NULL;
441 pid_t num_threads = 0;
444 struct cleanup *cleanups;
445 char procfs_dir[PATH_MAX];
447 snprintf (procfs_dir, sizeof (procfs_dir), "%s%s",
448 (nodestr != NULL) ? nodestr : "", "/proc");
450 dp = opendir (procfs_dir);
453 fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
454 procfs_dir, errno, safe_strerror (errno));
458 cleanups = make_cleanup (do_closedir_cleanup, dp);
460 /* Start scan at first pid. */
465 /* Get the right pid and procfs path for the pid. */
471 do_cleanups (cleanups);
474 snprintf (buf, sizeof (buf), "%s%s/%s/as",
475 (nodestr != NULL) ? nodestr : "",
476 "/proc", dirp->d_name);
477 pid = atoi (dirp->d_name);
481 /* Open the procfs path. */
482 scoped_fd fd (open (buf, O_RDONLY));
485 fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
486 buf, errno, safe_strerror (errno));
490 pidinfo = (procfs_info *) buf;
491 if (devctl (fd.get (), DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
493 fprintf_unfiltered (gdb_stderr,
494 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
495 errno, safe_strerror (errno));
498 num_threads = pidinfo->num_threads;
500 info = (procfs_debuginfo *) buf;
501 if (devctl (fd.get (), DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0)
503 strcpy (name, "unavailable");
505 strcpy (name, info->path);
507 /* Collect state info on all the threads. */
508 status = (procfs_status *) buf;
509 for (status->tid = 1; status->tid <= num_threads; status->tid++)
512 = devctl (fd.get (), DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0);
513 printf_filtered ("%s - %d", name, pid);
514 if (err == EOK && status->tid != 0)
515 printf_filtered ("/%d\n", status->tid);
518 printf_filtered ("\n");
523 while (dirp != NULL);
525 do_cleanups (cleanups);
530 procfs_meminfo (const char *args, int from_tty)
532 procfs_mapinfo *mapinfos = NULL;
533 static int num_mapinfos = 0;
534 procfs_mapinfo *mapinfo_p, *mapinfo_p2;
535 int flags = ~0, err, num, i, j;
539 procfs_debuginfo info;
540 char buff[_POSIX_PATH_MAX];
548 unsigned debug_vaddr;
549 unsigned long long offset;
554 unsigned long long ino;
561 /* Get the number of map entrys. */
562 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
565 printf ("failed devctl num mapinfos - %d (%s)\n", err,
566 safe_strerror (err));
570 mapinfos = XNEWVEC (procfs_mapinfo, num);
573 mapinfo_p = mapinfos;
575 /* Fill the map entrys. */
576 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
577 * sizeof (procfs_mapinfo), &num);
580 printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
585 num = std::min (num, num_mapinfos);
587 /* Run through the list of mapinfos, and store the data and text info
588 so we can print it at the bottom of the loop. */
589 for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
591 if (!(mapinfo_p->flags & flags))
594 if (mapinfo_p->ino == 0) /* Already visited. */
597 map.info.vaddr = mapinfo_p->vaddr;
599 err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
603 memset (&printme, 0, sizeof printme);
604 printme.dev = mapinfo_p->dev;
605 printme.ino = mapinfo_p->ino;
606 printme.text.addr = mapinfo_p->vaddr;
607 printme.text.size = mapinfo_p->size;
608 printme.text.flags = mapinfo_p->flags;
609 printme.text.offset = mapinfo_p->offset;
610 printme.text.debug_vaddr = map.info.vaddr;
611 strcpy (printme.name, map.info.path);
613 /* Check for matching data. */
614 for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
616 if (mapinfo_p2->vaddr != mapinfo_p->vaddr
617 && mapinfo_p2->ino == mapinfo_p->ino
618 && mapinfo_p2->dev == mapinfo_p->dev)
620 map.info.vaddr = mapinfo_p2->vaddr;
622 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
626 if (strcmp (map.info.path, printme.name))
629 /* Lower debug_vaddr is always text, if nessessary, swap. */
630 if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
632 memcpy (&(printme.data), &(printme.text),
633 sizeof (printme.data));
634 printme.text.addr = mapinfo_p2->vaddr;
635 printme.text.size = mapinfo_p2->size;
636 printme.text.flags = mapinfo_p2->flags;
637 printme.text.offset = mapinfo_p2->offset;
638 printme.text.debug_vaddr = map.info.vaddr;
642 printme.data.addr = mapinfo_p2->vaddr;
643 printme.data.size = mapinfo_p2->size;
644 printme.data.flags = mapinfo_p2->flags;
645 printme.data.offset = mapinfo_p2->offset;
646 printme.data.debug_vaddr = map.info.vaddr;
653 printf_filtered ("%s\n", printme.name);
654 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
656 printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
657 printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
658 printf_filtered ("\t\toffset=%s\n", phex (printme.text.offset, 8));
659 if (printme.data.size)
661 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
663 printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
664 printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
665 printf_filtered ("\t\toffset=%s\n", phex (printme.data.offset, 8));
667 printf_filtered ("\tdev=0x%x\n", printme.dev);
668 printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
674 /* Print status information about what we're accessing. */
676 nto_procfs_target::files_info ()
678 struct inferior *inf = current_inferior ();
680 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
681 inf->attach_flag ? "attached" : "child",
682 target_pid_to_str (inferior_ptid),
683 (nodestr != NULL) ? nodestr : "local node");
686 /* Target to_pid_to_exec_file implementation. */
689 nto_procfs_target::pid_to_exec_file (const int pid)
692 static char proc_path[PATH_MAX];
695 /* Read exe file name. */
696 snprintf (proc_path, sizeof (proc_path), "%s/proc/%d/exefile",
697 (nodestr != NULL) ? nodestr : "", pid);
698 proc_fd = open (proc_path, O_RDONLY);
702 rd = read (proc_fd, proc_path, sizeof (proc_path) - 1);
709 proc_path[rd] = '\0';
713 /* Attach to process PID, then initialize for debugging it. */
715 nto_procfs_target::attach (const char *args, int from_tty)
719 struct inferior *inf;
721 pid = parse_pid_to_attach (args);
723 if (pid == getpid ())
724 error (_("Attaching GDB to itself is not a good idea..."));
728 exec_file = (char *) get_exec_file (0);
731 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
732 target_pid_to_str (pid_to_ptid (pid)));
734 printf_unfiltered ("Attaching to %s\n",
735 target_pid_to_str (pid_to_ptid (pid)));
737 gdb_flush (gdb_stdout);
739 inferior_ptid = do_attach (pid_to_ptid (pid));
740 inf = current_inferior ();
741 inferior_appeared (inf, pid);
742 inf->attach_flag = 1;
744 if (!target_is_pushed (ops))
747 procfs_update_thread_list (ops);
751 nto_procfs_target::post_attach (pid_t pid)
754 solib_create_inferior_hook (0);
758 do_attach (ptid_t ptid)
760 procfs_status status;
761 struct sigevent event;
764 snprintf (path, PATH_MAX - 1, "%s%s/%d/as",
765 (nodestr != NULL) ? nodestr : "", "/proc", ptid_get_pid (ptid));
766 ctl_fd = open (path, O_RDWR);
768 error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
769 safe_strerror (errno));
770 if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
771 error (_("Couldn't stop process"));
773 /* Define a sigevent for process stopped notification. */
774 event.sigev_notify = SIGEV_SIGNAL_THREAD;
775 event.sigev_signo = SIGUSR1;
776 event.sigev_code = 0;
777 event.sigev_value.sival_ptr = NULL;
778 event.sigev_priority = -1;
779 devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
781 if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
782 && status.flags & _DEBUG_FLAG_STOPPED)
783 SignalKill (nto_node (), ptid_get_pid (ptid), 0, SIGCONT, 0, 0);
784 nto_init_solib_absolute_prefix ();
785 return ptid_build (ptid_get_pid (ptid), 0, status.tid);
788 /* Ask the user what to do when an interrupt is received. */
790 interrupt_query (void)
792 if (query (_("Interrupted while waiting for the program.\n\
793 Give up (and stop debugging it)? ")))
795 target_mourn_inferior (inferior_ptid);
800 /* The user typed ^C twice. */
802 nto_handle_sigint_twice (int signo)
804 signal (signo, ofunc);
806 signal (signo, nto_handle_sigint_twice);
810 nto_handle_sigint (int signo)
812 /* If this doesn't work, try more severe steps. */
813 signal (signo, nto_handle_sigint_twice);
819 nto_procfs_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
824 procfs_status status;
825 static int exit_signo = 0; /* To track signals that cause termination. */
827 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
829 if (ptid_equal (inferior_ptid, null_ptid))
831 ourstatus->kind = TARGET_WAITKIND_STOPPED;
832 ourstatus->value.sig = GDB_SIGNAL_0;
838 sigaddset (&set, SIGUSR1);
840 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
841 while (!(status.flags & _DEBUG_FLAG_ISTOP))
843 ofunc = signal (SIGINT, nto_handle_sigint);
844 sigwaitinfo (&set, &info);
845 signal (SIGINT, ofunc);
846 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
849 nto_inferior_data (NULL)->stopped_flags = status.flags;
850 nto_inferior_data (NULL)->stopped_pc = status.ip;
852 if (status.flags & _DEBUG_FLAG_SSTEP)
854 ourstatus->kind = TARGET_WAITKIND_STOPPED;
855 ourstatus->value.sig = GDB_SIGNAL_TRAP;
857 /* Was it a breakpoint? */
858 else if (status.flags & _DEBUG_FLAG_TRACE)
860 ourstatus->kind = TARGET_WAITKIND_STOPPED;
861 ourstatus->value.sig = GDB_SIGNAL_TRAP;
863 else if (status.flags & _DEBUG_FLAG_ISTOP)
867 case _DEBUG_WHY_SIGNALLED:
868 ourstatus->kind = TARGET_WAITKIND_STOPPED;
869 ourstatus->value.sig =
870 gdb_signal_from_host (status.info.si_signo);
873 case _DEBUG_WHY_FAULTED:
874 ourstatus->kind = TARGET_WAITKIND_STOPPED;
875 if (status.info.si_signo == SIGTRAP)
877 ourstatus->value.sig = 0;
882 ourstatus->value.sig =
883 gdb_signal_from_host (status.info.si_signo);
884 exit_signo = ourstatus->value.sig;
888 case _DEBUG_WHY_TERMINATED:
892 waitpid (ptid_get_pid (inferior_ptid), &waitval, WNOHANG);
895 /* Abnormal death. */
896 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
897 ourstatus->value.sig = exit_signo;
902 ourstatus->kind = TARGET_WAITKIND_EXITED;
903 ourstatus->value.integer = WEXITSTATUS (waitval);
909 case _DEBUG_WHY_REQUESTED:
910 /* We are assuming a requested stop is due to a SIGINT. */
911 ourstatus->kind = TARGET_WAITKIND_STOPPED;
912 ourstatus->value.sig = GDB_SIGNAL_INT;
918 return ptid_build (status.pid, 0, status.tid);
921 /* Read the current values of the inferior's registers, both the
922 general register set and floating point registers (if supported)
923 and update gdb's idea of their current values. */
925 nto_procfs_target::fetch_registers (struct regcache *regcache, int regno)
931 procfs_altreg altreg;
936 procfs_set_thread (regcache_get_ptid (regcache));
937 if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK)
938 nto_supply_gregset (regcache, (char *) ®.greg);
939 if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size)
941 nto_supply_fpregset (regcache, (char *) ®.fpreg);
942 if (devctl (ctl_fd, DCMD_PROC_GETALTREG, ®, sizeof (reg), ®size)
944 nto_supply_altregset (regcache, (char *) ®.altreg);
947 /* Helper for procfs_xfer_partial that handles memory transfers.
948 Arguments are like target_xfer_partial. */
950 static enum target_xfer_status
951 procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
952 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
956 if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr)
957 return TARGET_XFER_E_IO;
959 if (writebuf != NULL)
960 nbytes = write (ctl_fd, writebuf, len);
962 nbytes = read (ctl_fd, readbuf, len);
964 return TARGET_XFER_E_IO;
965 *xfered_len = nbytes;
966 return TARGET_XFER_OK;
969 /* Target to_xfer_partial implementation. */
971 enum target_xfer_status
972 nto_procfs_target::xfer_partial (enum target_object object,
973 const char *annex, gdb_byte *readbuf,
974 const gdb_byte *writebuf, ULONGEST offset,
975 ULONGEST len, ULONGEST *xfered_len)
979 case TARGET_OBJECT_MEMORY:
980 return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
981 case TARGET_OBJECT_AUXV:
985 CORE_ADDR initial_stack;
986 debug_process_t procinfo;
987 /* For 32-bit architecture, size of auxv_t is 8 bytes. */
988 const unsigned int sizeof_auxv_t = sizeof (auxv_t);
989 const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t;
991 gdb_byte *const tempbuf = alloca (sizeof_tempbuf);
994 return TARGET_XFER_E_IO;
996 err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo,
999 return TARGET_XFER_E_IO;
1001 initial_stack = procinfo.initial_stack;
1003 /* procfs is always 'self-hosted', no byte-order manipulation. */
1004 tempread = nto_read_auxv_from_initial_stack (initial_stack, tempbuf,
1007 tempread = std::min (tempread, len) - offset;
1008 memcpy (readbuf, tempbuf + offset, tempread);
1009 *xfered_len = tempread;
1010 return tempread ? TARGET_XFER_OK : TARGET_XFER_EOF;
1014 return this->beneath->xfer_partial (object, annex,
1015 readbuf, writebuf, offset, len,
1020 /* Take a program previously attached to and detaches it.
1021 The program resumes execution and will no longer stop
1022 on signals, etc. We'd better not have left any breakpoints
1023 in the program or it'll die when it hits one. */
1025 nto_procfs_target::detach (inferior *inf, int from_tty)
1029 target_announce_detach ();
1032 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, 0, 0, 0);
1037 pid = ptid_get_pid (inferior_ptid);
1038 inferior_ptid = null_ptid;
1039 detach_inferior (pid);
1040 init_thread_list ();
1041 inf_child_maybe_unpush_target (ops);
1045 procfs_breakpoint (CORE_ADDR addr, int type, int size)
1052 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1059 nto_procfs_target::insert_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, _DEBUG_BREAK_EXEC, 0);
1067 nto_procfs_target::remove_breakpoint (struct gdbarch *gdbarch,
1068 struct bp_target_info *bp_tgt,
1069 enum remove_bp_reason reason)
1071 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
1075 nto_procfs_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
1076 struct bp_target_info *bp_tgt)
1078 bp_tgt->placed_address = bp_tgt->reqstd_address;
1079 return procfs_breakpoint (bp_tgt->placed_address,
1080 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
1084 nto_procfs_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
1085 struct bp_target_info *bp_tgt)
1087 return procfs_breakpoint (bp_tgt->placed_address,
1088 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
1092 nto_procfs_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
1095 procfs_status status;
1096 sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
1098 if (ptid_equal (inferior_ptid, null_ptid))
1101 procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
1104 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
1106 run.flags |= _DEBUG_RUN_STEP;
1108 sigemptyset (run_fault);
1109 sigaddset (run_fault, FLTBPT);
1110 sigaddset (run_fault, FLTTRACE);
1111 sigaddset (run_fault, FLTILL);
1112 sigaddset (run_fault, FLTPRIV);
1113 sigaddset (run_fault, FLTBOUNDS);
1114 sigaddset (run_fault, FLTIOVF);
1115 sigaddset (run_fault, FLTIZDIV);
1116 sigaddset (run_fault, FLTFPE);
1117 /* Peter V will be changing this at some point. */
1118 sigaddset (run_fault, FLTPAGE);
1120 run.flags |= _DEBUG_RUN_ARM;
1122 signal_to_pass = gdb_signal_to_host (signo);
1126 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
1127 signal_to_pass = gdb_signal_to_host (signo);
1128 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
1130 if (signal_to_pass != status.info.si_signo)
1132 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0,
1133 signal_to_pass, 0, 0);
1134 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1136 else /* Let it kill the program without telling us. */
1137 sigdelset (&run.trace, signal_to_pass);
1141 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1143 errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1146 perror (_("run error!\n"));
1152 nto_procfs_target::mourn_inferior ()
1154 if (!ptid_equal (inferior_ptid, null_ptid))
1156 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, SIGKILL, 0, 0);
1159 inferior_ptid = null_ptid;
1160 init_thread_list ();
1161 inf_child_mourn_inferior (ops);
1164 /* This function breaks up an argument string into an argument
1165 vector suitable for passing to execvp().
1166 E.g., on "run a b c d" this routine would get as input
1167 the string "a b c d", and as output it would fill in argv with
1168 the four arguments "a", "b", "c", "d". The only additional
1169 functionality is simple quoting. The gdb command:
1171 will fill in argv with the three args "a", "b c d", "e". */
1173 breakup_args (char *scratch, char **argv)
1175 char *pp, *cp = scratch;
1180 /* Scan past leading separators. */
1182 while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1185 /* Break if at end of string. */
1193 quoting = strchr (cp, '"') ? 1 : 0;
1198 /* Scan for next arg separator. */
1201 cp = strchr (pp, '"');
1202 if ((cp == NULL) || (!quoting))
1203 cp = strchr (pp, ' ');
1205 cp = strchr (pp, '\t');
1207 cp = strchr (pp, '\n');
1209 /* No separators => end of string => break. */
1216 /* Replace the separator with a terminator. */
1220 /* Execv requires a null-terminated arg vector. */
1225 nto_procfs_target::create_inferior (const char *exec_file,
1226 const std::string &allargs,
1227 char **env, int from_tty)
1229 struct inheritance inherit;
1233 const char *in = "", *out = "", *err = "";
1236 const char *inferior_io_terminal = get_inferior_io_terminal ();
1237 struct inferior *inf;
1239 argv = xmalloc ((allargs.size () / (unsigned) 2 + 2) *
1241 argv[0] = get_exec_file (1);
1245 argv[0] = exec_file;
1250 args = xstrdup (allargs.c_str ());
1251 breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]);
1253 argv = nto_parse_redirection (argv, &in, &out, &err);
1255 fds[0] = STDIN_FILENO;
1256 fds[1] = STDOUT_FILENO;
1257 fds[2] = STDERR_FILENO;
1259 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1260 if the i/o is not also being specified via redirection. */
1261 if (inferior_io_terminal)
1264 in = inferior_io_terminal;
1266 out = inferior_io_terminal;
1268 err = inferior_io_terminal;
1273 fd = open (in, O_RDONLY);
1281 fd = open (out, O_WRONLY);
1289 fd = open (err, O_WRONLY);
1296 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1297 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1300 sigaddset (&set, SIGUSR1);
1301 sigprocmask (SIG_UNBLOCK, &set, NULL);
1303 memset (&inherit, 0, sizeof (inherit));
1305 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1307 inherit.nd = nto_node ();
1308 inherit.flags |= SPAWN_SETND;
1309 inherit.flags &= ~SPAWN_EXEC;
1311 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1312 inherit.pgroup = SPAWN_NEWPGROUP;
1313 pid = spawnp (argv[0], 3, fds, &inherit, argv,
1314 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1317 sigprocmask (SIG_BLOCK, &set, NULL);
1320 error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1321 safe_strerror (errno));
1323 if (fds[0] != STDIN_FILENO)
1325 if (fds[1] != STDOUT_FILENO)
1327 if (fds[2] != STDERR_FILENO)
1330 inferior_ptid = do_attach (pid_to_ptid (pid));
1331 procfs_update_thread_list (ops);
1333 inf = current_inferior ();
1334 inferior_appeared (inf, pid);
1335 inf->attach_flag = 0;
1337 flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */
1338 errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1341 /* FIXME: expected warning? */
1342 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1343 errn, strerror(errn) ); */
1345 if (!target_is_pushed (ops))
1347 target_terminal::init ();
1349 if (exec_bfd != NULL
1350 || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1351 solib_create_inferior_hook (0);
1355 nto_procfs_target::interrupt ()
1357 devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1361 nto_procfs_target::kill ()
1363 target_mourn_inferior (inferior_ptid);
1366 /* Fill buf with regset and return devctl cmd to do the setting. Return
1367 -1 if we fail to get the regset. Store size of regset in regsize. */
1369 get_regset (int regset, char *buf, int bufsize, int *regsize)
1371 int dev_get, dev_set;
1374 case NTO_REG_GENERAL:
1375 dev_get = DCMD_PROC_GETGREG;
1376 dev_set = DCMD_PROC_SETGREG;
1380 dev_get = DCMD_PROC_GETFPREG;
1381 dev_set = DCMD_PROC_SETFPREG;
1385 dev_get = DCMD_PROC_GETALTREG;
1386 dev_set = DCMD_PROC_SETALTREG;
1389 case NTO_REG_SYSTEM:
1393 if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1400 nto_procfs_target::store_registers (struct regcache *regcache, int regno)
1406 procfs_altreg altreg;
1410 int len, regset, regsize, dev_set, err;
1412 ptid_t ptid = regcache_get_ptid (regcache);
1414 if (ptid_equal (ptid, null_ptid))
1416 procfs_set_thread (ptid);
1420 for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1422 dev_set = get_regset (regset, (char *) ®,
1423 sizeof (reg), ®size);
1427 if (nto_regset_fill (regcache, regset, (char *) ®) == -1)
1430 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1432 fprintf_unfiltered (gdb_stderr,
1433 "Warning unable to write regset %d: %s\n",
1434 regno, safe_strerror (err));
1439 regset = nto_regset_id (regno);
1443 dev_set = get_regset (regset, (char *) ®, sizeof (reg), ®size);
1447 len = nto_register_area (regcache->arch (),
1448 regno, regset, &off);
1453 regcache_raw_collect (regcache, regno, (char *) ® + off);
1455 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1457 fprintf_unfiltered (gdb_stderr,
1458 "Warning unable to write regset %d: %s\n", regno,
1459 safe_strerror (err));
1463 /* Set list of signals to be handled in the target. */
1466 nto_procfs_target::pass_signals (int numsigs, unsigned char *pass_signals)
1470 sigfillset (&run.trace);
1472 for (signo = 1; signo < NSIG; signo++)
1474 int target_signo = gdb_signal_from_host (signo);
1475 if (target_signo < numsigs && pass_signals[target_signo])
1476 sigdelset (&run.trace, signo);
1481 nto_procfs_target::pid_to_str (ptid_t ptid)
1483 static char buf[1024];
1485 struct tidinfo *tip;
1487 pid = ptid_get_pid (ptid);
1488 tid = ptid_get_tid (ptid);
1490 n = snprintf (buf, 1023, "process %d", pid);
1493 tip = procfs_thread_info (pid, tid);
1495 snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1501 /* to_can_run implementation for "target procfs". Note this really
1502 means "can this target be the default run target", which there can
1503 be only one, and we make it be "target native" like other ports.
1504 "target procfs <node>" wouldn't make sense as default run target, as
1508 nto_procfs_target::can_run ()
1513 /* "target procfs". */
1514 static nto_procfs_target_procfs nto_procfs_ops;
1516 /* "target native". */
1517 static nto_procfs_target_native nto_native_ops;
1519 /* Create the "native" and "procfs" targets. */
1522 init_procfs_targets (void)
1524 /* Register "target native". This is the default run target. */
1525 add_target (nto_native_target_info, inf_child_open_target);
1526 set_native_target (&nto_native_ops);
1528 /* Register "target procfs <node>". */
1529 add_target (nto_procfs_target_info, inf_child_open_target);
1532 #define OSTYPE_NTO 1
1535 _initialize_procfs (void)
1539 init_procfs_targets ();
1541 /* We use SIGUSR1 to gain control after we block waiting for a process.
1542 We use sigwaitevent to wait. */
1544 sigaddset (&set, SIGUSR1);
1545 sigprocmask (SIG_BLOCK, &set, NULL);
1547 /* Initially, make sure all signals are reported. */
1548 sigfillset (&run.trace);
1550 /* Stuff some information. */
1551 nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1552 nto_cpuinfo_valid = 1;
1554 add_info ("pidlist", procfs_pidlist, _("pidlist"));
1555 add_info ("meminfo", procfs_meminfo, _("memory information"));
1557 nto_is_nto_target = procfs_is_nto_target;
1562 procfs_hw_watchpoint (int addr, int len, enum target_hw_bp_type type)
1569 brk.type = _DEBUG_BREAK_RD;
1572 brk.type = _DEBUG_BREAK_RW;
1574 default: /* Modify. */
1575 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1576 brk.type = _DEBUG_BREAK_RW;
1578 brk.type |= _DEBUG_BREAK_HW; /* Always ask for HW. */
1582 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1585 perror (_("Failed to set hardware watchpoint"));
1592 nto_procfs_target::can_use_hw_breakpoint (enum bptype type,
1593 int cnt, int othertype)
1599 nto_procfs_target::remove_hw_watchpoint (CORE_ADDR addr, int len,
1600 enum target_hw_bp_type type,
1601 struct expression *cond)
1603 return procfs_hw_watchpoint (addr, -1, type);
1607 nto_procfs_target::insert_hw_watchpoint (CORE_ADDR addr, int len,
1608 enum target_hw_bp_type type,
1609 struct expression *cond)
1611 return procfs_hw_watchpoint (addr, len, type);
1615 nto_procfs_target::stopped_by_watchpoint ()
1617 /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are
1618 stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode;
1619 future gdb versions will likely run in 'non-stop' mode in which case
1620 we will have to store/examine statuses per thread in question.
1621 Until then, this will work fine. */
1623 struct inferior *inf = current_inferior ();
1624 struct nto_inferior_data *inf_data;
1626 gdb_assert (inf != NULL);
1628 inf_data = nto_inferior_data (inf);
1630 return inf_data->stopped_flags
1631 & (_DEBUG_FLAG_TRACE_RD
1632 | _DEBUG_FLAG_TRACE_WR
1633 | _DEBUG_FLAG_TRACE_MODIFY);