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"
48 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
49 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
53 static sighandler_t ofunc;
55 static procfs_run run;
57 static ptid_t do_attach (ptid_t ptid);
59 static int procfs_can_use_hw_breakpoint (struct target_ops *self,
60 enum bptype, int, int);
62 static int procfs_insert_hw_watchpoint (struct target_ops *self,
63 CORE_ADDR addr, int len,
64 enum target_hw_bp_type type,
65 struct expression *cond);
67 static int procfs_remove_hw_watchpoint (struct target_ops *self,
68 CORE_ADDR addr, int len,
69 enum target_hw_bp_type type,
70 struct expression *cond);
72 static int procfs_stopped_by_watchpoint (struct target_ops *ops);
74 /* These two globals are only ever set in procfs_open_1, but are
75 referenced elsewhere. 'nto_procfs_node' is a flag used to say
76 whether we are local, or we should get the current node descriptor
77 for the remote QNX node. */
79 static unsigned nto_procfs_node = ND_LOCAL_NODE;
81 /* Return the current QNX Node, or error out. This is a simple
82 wrapper for the netmgr_strtond() function. The reason this
83 is required is because QNX node descriptors are transient so
84 we have to re-acquire them every time. */
90 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0
94 node = netmgr_strtond (nodestr, 0);
96 error (_("Lost the QNX node. Debug session probably over."));
101 static enum gdb_osabi
102 procfs_is_nto_target (bfd *abfd)
104 return GDB_OSABI_QNXNTO;
107 /* This is called when we call 'target native' or 'target procfs
108 <arg>' from the (gdb) prompt. For QNX6 (nto), the only valid arg
109 will be a QNX node string, eg: "/net/some_node". If arg is not a
110 valid QNX node, we will default to local. */
112 procfs_open_1 (struct target_ops *ops, const char *arg, int from_tty)
117 procfs_sysinfo *sysinfo;
118 struct cleanup *cleanups;
119 char nto_procfs_path[PATH_MAX];
121 /* Offer to kill previous inferiors before opening this target. */
122 target_preopen (from_tty);
124 nto_is_nto_target = procfs_is_nto_target;
126 /* Set the default node used for spawning to this one,
127 and only override it if there is a valid arg. */
132 nto_procfs_node = ND_LOCAL_NODE;
133 nodestr = (arg != NULL) ? xstrdup (arg) : NULL;
139 nto_procfs_node = netmgr_strtond (nodestr, &endstr);
140 if (nto_procfs_node == -1)
142 if (errno == ENOTSUP)
143 printf_filtered ("QNX Net Manager not found.\n");
144 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr,
145 errno, safe_strerror (errno));
148 nto_procfs_node = ND_LOCAL_NODE;
152 if (*(endstr - 1) == '/')
158 snprintf (nto_procfs_path, PATH_MAX - 1, "%s%s",
159 (nodestr != NULL) ? nodestr : "", "/proc");
161 fd = open (nto_procfs_path, O_RDONLY);
164 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path, errno,
165 safe_strerror (errno));
166 error (_("Invalid procfs arg"));
168 cleanups = make_cleanup_close (fd);
170 sysinfo = (void *) buffer;
171 if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, sizeof buffer, 0) != EOK)
173 printf_filtered ("Error getting size: %d (%s)\n", errno,
174 safe_strerror (errno));
175 error (_("Devctl failed."));
179 total_size = sysinfo->total_size;
180 sysinfo = alloca (total_size);
183 printf_filtered ("Memory error: %d (%s)\n", errno,
184 safe_strerror (errno));
185 error (_("alloca failed."));
189 if (devctl (fd, DCMD_PROC_SYSINFO, sysinfo, total_size, 0) != EOK)
191 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno,
192 safe_strerror (errno));
193 error (_("Devctl failed."));
198 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
199 (target_gdbarch ())->arch_name))
200 error (_("Invalid target CPU."));
204 do_cleanups (cleanups);
206 inf_child_open_target (ops, arg, from_tty);
207 printf_filtered ("Debugging using %s\n", nto_procfs_path);
211 procfs_set_thread (ptid_t ptid)
215 tid = ptid_get_tid (ptid);
216 devctl (ctl_fd, DCMD_PROC_CURTHREAD, &tid, sizeof (tid), 0);
219 /* Return nonzero if the thread TH is still alive. */
221 procfs_thread_alive (struct target_ops *ops, ptid_t ptid)
225 procfs_status status;
228 tid = ptid_get_tid (ptid);
229 pid = ptid_get_pid (ptid);
231 if (kill (pid, 0) == -1)
235 if ((err = devctl (ctl_fd, DCMD_PROC_TIDSTATUS,
236 &status, sizeof (status), 0)) != EOK)
239 /* Thread is alive or dead but not yet joined,
240 or dead and there is an alive (or dead unjoined) thread with
243 If the tid is not the same as requested, requested tid is dead. */
244 return (status.tid == tid) && (status.state != STATE_DEAD);
248 update_thread_private_data_name (struct thread_info *new_thread,
251 nto_thread_info *pti = get_nto_thread_info (new_thread);
253 gdb_assert (newname != NULL);
254 gdb_assert (new_thread != NULL);
258 pti = new nto_thread_info;
259 new_thread->priv.reset (pti);
266 update_thread_private_data (struct thread_info *new_thread,
267 pthread_t tid, int state, int flags)
270 struct _thread_name *tn;
271 procfs_threadctl tctl;
273 #if _NTO_VERSION > 630
274 gdb_assert (new_thread != NULL);
276 if (devctl (ctl_fd, DCMD_PROC_INFO, &pidinfo,
277 sizeof(pidinfo), 0) != EOK)
280 memset (&tctl, 0, sizeof (tctl));
281 tctl.cmd = _NTO_TCTL_NAME;
282 tn = (struct _thread_name *) (&tctl.data);
284 /* Fetch name for the given thread. */
286 tn->name_buf_len = sizeof (tctl.data) - sizeof (*tn);
287 tn->new_name_len = -1; /* Getting, not setting. */
288 if (devctl (ctl_fd, DCMD_PROC_THREADCTL, &tctl, sizeof (tctl), NULL) != EOK)
289 tn->name_buf[0] = '\0';
291 tn->name_buf[_NTO_THREAD_NAME_MAX] = '\0';
293 update_thread_private_data_name (new_thread, tn->name_buf);
295 nto_thread_info *pti = get_nto_thread_info (new_thread);
299 #endif /* _NTO_VERSION */
303 procfs_update_thread_list (struct target_ops *ops)
305 procfs_status status;
309 struct thread_info *new_thread;
316 pid = ptid_get_pid (inferior_ptid);
320 for (tid = 1;; ++tid)
322 if (status.tid == tid
323 && (devctl (ctl_fd, DCMD_PROC_TIDSTATUS, &status, sizeof (status), 0)
326 if (status.tid != tid)
327 /* The reason why this would not be equal is that devctl might have
328 returned different tid, meaning the requested tid no longer exists
329 (e.g. thread exited). */
331 ptid = ptid_build (pid, 0, tid);
332 new_thread = find_thread_ptid (ptid);
334 new_thread = add_thread (ptid);
335 update_thread_private_data (new_thread, tid, status.state, 0);
342 do_closedir_cleanup (void *dir)
348 procfs_pidlist (const char *args, int from_tty)
351 struct dirent *dirp = NULL;
353 procfs_info *pidinfo = NULL;
354 procfs_debuginfo *info = NULL;
355 procfs_status *status = NULL;
356 pid_t num_threads = 0;
359 struct cleanup *cleanups;
360 char procfs_dir[PATH_MAX];
362 snprintf (procfs_dir, sizeof (procfs_dir), "%s%s",
363 (nodestr != NULL) ? nodestr : "", "/proc");
365 dp = opendir (procfs_dir);
368 fprintf_unfiltered (gdb_stderr, "failed to opendir \"%s\" - %d (%s)",
369 procfs_dir, errno, safe_strerror (errno));
373 cleanups = make_cleanup (do_closedir_cleanup, dp);
375 /* Start scan at first pid. */
381 struct cleanup *inner_cleanup;
383 /* Get the right pid and procfs path for the pid. */
389 do_cleanups (cleanups);
392 snprintf (buf, sizeof (buf), "%s%s/%s/as",
393 (nodestr != NULL) ? nodestr : "",
394 "/proc", dirp->d_name);
395 pid = atoi (dirp->d_name);
399 /* Open the procfs path. */
400 fd = open (buf, O_RDONLY);
403 fprintf_unfiltered (gdb_stderr, "failed to open %s - %d (%s)\n",
404 buf, errno, safe_strerror (errno));
407 inner_cleanup = make_cleanup_close (fd);
409 pidinfo = (procfs_info *) buf;
410 if (devctl (fd, DCMD_PROC_INFO, pidinfo, sizeof (buf), 0) != EOK)
412 fprintf_unfiltered (gdb_stderr,
413 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
414 errno, safe_strerror (errno));
417 num_threads = pidinfo->num_threads;
419 info = (procfs_debuginfo *) buf;
420 if (devctl (fd, DCMD_PROC_MAPDEBUG_BASE, info, sizeof (buf), 0) != EOK)
421 strcpy (name, "unavailable");
423 strcpy (name, info->path);
425 /* Collect state info on all the threads. */
426 status = (procfs_status *) buf;
427 for (status->tid = 1; status->tid <= num_threads; status->tid++)
430 = devctl (fd, DCMD_PROC_TIDSTATUS, status, sizeof (buf), 0);
431 printf_filtered ("%s - %d", name, pid);
432 if (err == EOK && status->tid != 0)
433 printf_filtered ("/%d\n", status->tid);
436 printf_filtered ("\n");
441 do_cleanups (inner_cleanup);
443 while (dirp != NULL);
445 do_cleanups (cleanups);
450 procfs_meminfo (const char *args, int from_tty)
452 procfs_mapinfo *mapinfos = NULL;
453 static int num_mapinfos = 0;
454 procfs_mapinfo *mapinfo_p, *mapinfo_p2;
455 int flags = ~0, err, num, i, j;
459 procfs_debuginfo info;
460 char buff[_POSIX_PATH_MAX];
468 unsigned debug_vaddr;
469 unsigned long long offset;
474 unsigned long long ino;
481 /* Get the number of map entrys. */
482 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, NULL, 0, &num);
485 printf ("failed devctl num mapinfos - %d (%s)\n", err,
486 safe_strerror (err));
490 mapinfos = XNEWVEC (procfs_mapinfo, num);
493 mapinfo_p = mapinfos;
495 /* Fill the map entrys. */
496 err = devctl (ctl_fd, DCMD_PROC_MAPINFO, mapinfo_p, num
497 * sizeof (procfs_mapinfo), &num);
500 printf ("failed devctl mapinfos - %d (%s)\n", err, safe_strerror (err));
505 num = std::min (num, num_mapinfos);
507 /* Run through the list of mapinfos, and store the data and text info
508 so we can print it at the bottom of the loop. */
509 for (mapinfo_p = mapinfos, i = 0; i < num; i++, mapinfo_p++)
511 if (!(mapinfo_p->flags & flags))
514 if (mapinfo_p->ino == 0) /* Already visited. */
517 map.info.vaddr = mapinfo_p->vaddr;
519 err = devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
523 memset (&printme, 0, sizeof printme);
524 printme.dev = mapinfo_p->dev;
525 printme.ino = mapinfo_p->ino;
526 printme.text.addr = mapinfo_p->vaddr;
527 printme.text.size = mapinfo_p->size;
528 printme.text.flags = mapinfo_p->flags;
529 printme.text.offset = mapinfo_p->offset;
530 printme.text.debug_vaddr = map.info.vaddr;
531 strcpy (printme.name, map.info.path);
533 /* Check for matching data. */
534 for (mapinfo_p2 = mapinfos, j = 0; j < num; j++, mapinfo_p2++)
536 if (mapinfo_p2->vaddr != mapinfo_p->vaddr
537 && mapinfo_p2->ino == mapinfo_p->ino
538 && mapinfo_p2->dev == mapinfo_p->dev)
540 map.info.vaddr = mapinfo_p2->vaddr;
542 devctl (ctl_fd, DCMD_PROC_MAPDEBUG, &map, sizeof (map), 0);
546 if (strcmp (map.info.path, printme.name))
549 /* Lower debug_vaddr is always text, if nessessary, swap. */
550 if ((int) map.info.vaddr < (int) printme.text.debug_vaddr)
552 memcpy (&(printme.data), &(printme.text),
553 sizeof (printme.data));
554 printme.text.addr = mapinfo_p2->vaddr;
555 printme.text.size = mapinfo_p2->size;
556 printme.text.flags = mapinfo_p2->flags;
557 printme.text.offset = mapinfo_p2->offset;
558 printme.text.debug_vaddr = map.info.vaddr;
562 printme.data.addr = mapinfo_p2->vaddr;
563 printme.data.size = mapinfo_p2->size;
564 printme.data.flags = mapinfo_p2->flags;
565 printme.data.offset = mapinfo_p2->offset;
566 printme.data.debug_vaddr = map.info.vaddr;
573 printf_filtered ("%s\n", printme.name);
574 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme.text.size,
576 printf_filtered ("\t\tflags=%08x\n", printme.text.flags);
577 printf_filtered ("\t\tdebug=%08x\n", printme.text.debug_vaddr);
578 printf_filtered ("\t\toffset=%s\n", phex (printme.text.offset, 8));
579 if (printme.data.size)
581 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme.data.size,
583 printf_filtered ("\t\tflags=%08x\n", printme.data.flags);
584 printf_filtered ("\t\tdebug=%08x\n", printme.data.debug_vaddr);
585 printf_filtered ("\t\toffset=%s\n", phex (printme.data.offset, 8));
587 printf_filtered ("\tdev=0x%x\n", printme.dev);
588 printf_filtered ("\tino=0x%x\n", (unsigned int) printme.ino);
594 /* Print status information about what we're accessing. */
596 procfs_files_info (struct target_ops *ignore)
598 struct inferior *inf = current_inferior ();
600 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
601 inf->attach_flag ? "attached" : "child",
602 target_pid_to_str (inferior_ptid),
603 (nodestr != NULL) ? nodestr : "local node");
606 /* Target to_pid_to_exec_file implementation. */
609 procfs_pid_to_exec_file (struct target_ops *ops, const int pid)
612 static char proc_path[PATH_MAX];
615 /* Read exe file name. */
616 snprintf (proc_path, sizeof (proc_path), "%s/proc/%d/exefile",
617 (nodestr != NULL) ? nodestr : "", pid);
618 proc_fd = open (proc_path, O_RDONLY);
622 rd = read (proc_fd, proc_path, sizeof (proc_path) - 1);
629 proc_path[rd] = '\0';
633 /* Attach to process PID, then initialize for debugging it. */
635 procfs_attach (struct target_ops *ops, const char *args, int from_tty)
639 struct inferior *inf;
641 pid = parse_pid_to_attach (args);
643 if (pid == getpid ())
644 error (_("Attaching GDB to itself is not a good idea..."));
648 exec_file = (char *) get_exec_file (0);
651 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file,
652 target_pid_to_str (pid_to_ptid (pid)));
654 printf_unfiltered ("Attaching to %s\n",
655 target_pid_to_str (pid_to_ptid (pid)));
657 gdb_flush (gdb_stdout);
659 inferior_ptid = do_attach (pid_to_ptid (pid));
660 inf = current_inferior ();
661 inferior_appeared (inf, pid);
662 inf->attach_flag = 1;
664 if (!target_is_pushed (ops))
667 procfs_update_thread_list (ops);
671 procfs_post_attach (struct target_ops *self, pid_t pid)
674 solib_create_inferior_hook (0);
678 do_attach (ptid_t ptid)
680 procfs_status status;
681 struct sigevent event;
684 snprintf (path, PATH_MAX - 1, "%s%s/%d/as",
685 (nodestr != NULL) ? nodestr : "", "/proc", ptid_get_pid (ptid));
686 ctl_fd = open (path, O_RDWR);
688 error (_("Couldn't open proc file %s, error %d (%s)"), path, errno,
689 safe_strerror (errno));
690 if (devctl (ctl_fd, DCMD_PROC_STOP, &status, sizeof (status), 0) != EOK)
691 error (_("Couldn't stop process"));
693 /* Define a sigevent for process stopped notification. */
694 event.sigev_notify = SIGEV_SIGNAL_THREAD;
695 event.sigev_signo = SIGUSR1;
696 event.sigev_code = 0;
697 event.sigev_value.sival_ptr = NULL;
698 event.sigev_priority = -1;
699 devctl (ctl_fd, DCMD_PROC_EVENT, &event, sizeof (event), 0);
701 if (devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0) == EOK
702 && status.flags & _DEBUG_FLAG_STOPPED)
703 SignalKill (nto_node (), ptid_get_pid (ptid), 0, SIGCONT, 0, 0);
704 nto_init_solib_absolute_prefix ();
705 return ptid_build (ptid_get_pid (ptid), 0, status.tid);
708 /* Ask the user what to do when an interrupt is received. */
710 interrupt_query (void)
712 if (query (_("Interrupted while waiting for the program.\n\
713 Give up (and stop debugging it)? ")))
715 target_mourn_inferior (inferior_ptid);
720 /* The user typed ^C twice. */
722 nto_handle_sigint_twice (int signo)
724 signal (signo, ofunc);
726 signal (signo, nto_handle_sigint_twice);
730 nto_handle_sigint (int signo)
732 /* If this doesn't work, try more severe steps. */
733 signal (signo, nto_handle_sigint_twice);
735 target_interrupt (inferior_ptid);
739 procfs_wait (struct target_ops *ops,
740 ptid_t ptid, struct target_waitstatus *ourstatus, int options)
744 procfs_status status;
745 static int exit_signo = 0; /* To track signals that cause termination. */
747 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
749 if (ptid_equal (inferior_ptid, null_ptid))
751 ourstatus->kind = TARGET_WAITKIND_STOPPED;
752 ourstatus->value.sig = GDB_SIGNAL_0;
758 sigaddset (&set, SIGUSR1);
760 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
761 while (!(status.flags & _DEBUG_FLAG_ISTOP))
763 ofunc = signal (SIGINT, nto_handle_sigint);
764 sigwaitinfo (&set, &info);
765 signal (SIGINT, ofunc);
766 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
769 nto_inferior_data (NULL)->stopped_flags = status.flags;
770 nto_inferior_data (NULL)->stopped_pc = status.ip;
772 if (status.flags & _DEBUG_FLAG_SSTEP)
774 ourstatus->kind = TARGET_WAITKIND_STOPPED;
775 ourstatus->value.sig = GDB_SIGNAL_TRAP;
777 /* Was it a breakpoint? */
778 else if (status.flags & _DEBUG_FLAG_TRACE)
780 ourstatus->kind = TARGET_WAITKIND_STOPPED;
781 ourstatus->value.sig = GDB_SIGNAL_TRAP;
783 else if (status.flags & _DEBUG_FLAG_ISTOP)
787 case _DEBUG_WHY_SIGNALLED:
788 ourstatus->kind = TARGET_WAITKIND_STOPPED;
789 ourstatus->value.sig =
790 gdb_signal_from_host (status.info.si_signo);
793 case _DEBUG_WHY_FAULTED:
794 ourstatus->kind = TARGET_WAITKIND_STOPPED;
795 if (status.info.si_signo == SIGTRAP)
797 ourstatus->value.sig = 0;
802 ourstatus->value.sig =
803 gdb_signal_from_host (status.info.si_signo);
804 exit_signo = ourstatus->value.sig;
808 case _DEBUG_WHY_TERMINATED:
812 waitpid (ptid_get_pid (inferior_ptid), &waitval, WNOHANG);
815 /* Abnormal death. */
816 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
817 ourstatus->value.sig = exit_signo;
822 ourstatus->kind = TARGET_WAITKIND_EXITED;
823 ourstatus->value.integer = WEXITSTATUS (waitval);
829 case _DEBUG_WHY_REQUESTED:
830 /* We are assuming a requested stop is due to a SIGINT. */
831 ourstatus->kind = TARGET_WAITKIND_STOPPED;
832 ourstatus->value.sig = GDB_SIGNAL_INT;
838 return ptid_build (status.pid, 0, status.tid);
841 /* Read the current values of the inferior's registers, both the
842 general register set and floating point registers (if supported)
843 and update gdb's idea of their current values. */
845 procfs_fetch_registers (struct target_ops *ops,
846 struct regcache *regcache, int regno)
852 procfs_altreg altreg;
857 procfs_set_thread (regcache_get_ptid (regcache));
858 if (devctl (ctl_fd, DCMD_PROC_GETGREG, ®, sizeof (reg), ®size) == EOK)
859 nto_supply_gregset (regcache, (char *) ®.greg);
860 if (devctl (ctl_fd, DCMD_PROC_GETFPREG, ®, sizeof (reg), ®size)
862 nto_supply_fpregset (regcache, (char *) ®.fpreg);
863 if (devctl (ctl_fd, DCMD_PROC_GETALTREG, ®, sizeof (reg), ®size)
865 nto_supply_altregset (regcache, (char *) ®.altreg);
868 /* Helper for procfs_xfer_partial that handles memory transfers.
869 Arguments are like target_xfer_partial. */
871 static enum target_xfer_status
872 procfs_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
873 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
877 if (lseek (ctl_fd, (off_t) memaddr, SEEK_SET) != (off_t) memaddr)
878 return TARGET_XFER_E_IO;
880 if (writebuf != NULL)
881 nbytes = write (ctl_fd, writebuf, len);
883 nbytes = read (ctl_fd, readbuf, len);
885 return TARGET_XFER_E_IO;
886 *xfered_len = nbytes;
887 return TARGET_XFER_OK;
890 /* Target to_xfer_partial implementation. */
892 static enum target_xfer_status
893 procfs_xfer_partial (struct target_ops *ops, enum target_object object,
894 const char *annex, gdb_byte *readbuf,
895 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
896 ULONGEST *xfered_len)
900 case TARGET_OBJECT_MEMORY:
901 return procfs_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
902 case TARGET_OBJECT_AUXV:
906 CORE_ADDR initial_stack;
907 debug_process_t procinfo;
908 /* For 32-bit architecture, size of auxv_t is 8 bytes. */
909 const unsigned int sizeof_auxv_t = sizeof (auxv_t);
910 const unsigned int sizeof_tempbuf = 20 * sizeof_auxv_t;
912 gdb_byte *const tempbuf = alloca (sizeof_tempbuf);
915 return TARGET_XFER_E_IO;
917 err = devctl (ctl_fd, DCMD_PROC_INFO, &procinfo,
920 return TARGET_XFER_E_IO;
922 initial_stack = procinfo.initial_stack;
924 /* procfs is always 'self-hosted', no byte-order manipulation. */
925 tempread = nto_read_auxv_from_initial_stack (initial_stack, tempbuf,
928 tempread = std::min (tempread, len) - offset;
929 memcpy (readbuf, tempbuf + offset, tempread);
930 *xfered_len = tempread;
931 return tempread ? TARGET_XFER_OK : TARGET_XFER_EOF;
935 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
936 readbuf, writebuf, offset, len,
941 /* Take a program previously attached to and detaches it.
942 The program resumes execution and will no longer stop
943 on signals, etc. We'd better not have left any breakpoints
944 in the program or it'll die when it hits one. */
946 procfs_detach (struct target_ops *ops, const char *args, int from_tty)
951 target_announce_detach ();
954 siggnal = atoi (args);
957 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, siggnal, 0, 0);
962 pid = ptid_get_pid (inferior_ptid);
963 inferior_ptid = null_ptid;
964 detach_inferior (pid);
966 inf_child_maybe_unpush_target (ops);
970 procfs_breakpoint (CORE_ADDR addr, int type, int size)
977 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
984 procfs_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
985 struct bp_target_info *bp_tgt)
987 bp_tgt->placed_address = bp_tgt->reqstd_address;
988 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, 0);
992 procfs_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
993 struct bp_target_info *bp_tgt,
994 enum remove_bp_reason reason)
996 return procfs_breakpoint (bp_tgt->placed_address, _DEBUG_BREAK_EXEC, -1);
1000 procfs_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
1001 struct bp_target_info *bp_tgt)
1003 bp_tgt->placed_address = bp_tgt->reqstd_address;
1004 return procfs_breakpoint (bp_tgt->placed_address,
1005 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, 0);
1009 procfs_remove_hw_breakpoint (struct target_ops *self,
1010 struct gdbarch *gdbarch,
1011 struct bp_target_info *bp_tgt)
1013 return procfs_breakpoint (bp_tgt->placed_address,
1014 _DEBUG_BREAK_EXEC | _DEBUG_BREAK_HW, -1);
1018 procfs_resume (struct target_ops *ops,
1019 ptid_t ptid, int step, enum gdb_signal signo)
1022 procfs_status status;
1023 sigset_t *run_fault = (sigset_t *) (void *) &run.fault;
1025 if (ptid_equal (inferior_ptid, null_ptid))
1028 procfs_set_thread (ptid_equal (ptid, minus_one_ptid) ? inferior_ptid :
1031 run.flags = _DEBUG_RUN_FAULT | _DEBUG_RUN_TRACE;
1033 run.flags |= _DEBUG_RUN_STEP;
1035 sigemptyset (run_fault);
1036 sigaddset (run_fault, FLTBPT);
1037 sigaddset (run_fault, FLTTRACE);
1038 sigaddset (run_fault, FLTILL);
1039 sigaddset (run_fault, FLTPRIV);
1040 sigaddset (run_fault, FLTBOUNDS);
1041 sigaddset (run_fault, FLTIOVF);
1042 sigaddset (run_fault, FLTIZDIV);
1043 sigaddset (run_fault, FLTFPE);
1044 /* Peter V will be changing this at some point. */
1045 sigaddset (run_fault, FLTPAGE);
1047 run.flags |= _DEBUG_RUN_ARM;
1049 signal_to_pass = gdb_signal_to_host (signo);
1053 devctl (ctl_fd, DCMD_PROC_STATUS, &status, sizeof (status), 0);
1054 signal_to_pass = gdb_signal_to_host (signo);
1055 if (status.why & (_DEBUG_WHY_SIGNALLED | _DEBUG_WHY_FAULTED))
1057 if (signal_to_pass != status.info.si_signo)
1059 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0,
1060 signal_to_pass, 0, 0);
1061 run.flags |= _DEBUG_RUN_CLRFLT | _DEBUG_RUN_CLRSIG;
1063 else /* Let it kill the program without telling us. */
1064 sigdelset (&run.trace, signal_to_pass);
1068 run.flags |= _DEBUG_RUN_CLRSIG | _DEBUG_RUN_CLRFLT;
1070 errno = devctl (ctl_fd, DCMD_PROC_RUN, &run, sizeof (run), 0);
1073 perror (_("run error!\n"));
1079 procfs_mourn_inferior (struct target_ops *ops)
1081 if (!ptid_equal (inferior_ptid, null_ptid))
1083 SignalKill (nto_node (), ptid_get_pid (inferior_ptid), 0, SIGKILL, 0, 0);
1086 inferior_ptid = null_ptid;
1087 init_thread_list ();
1088 inf_child_mourn_inferior (ops);
1091 /* This function breaks up an argument string into an argument
1092 vector suitable for passing to execvp().
1093 E.g., on "run a b c d" this routine would get as input
1094 the string "a b c d", and as output it would fill in argv with
1095 the four arguments "a", "b", "c", "d". The only additional
1096 functionality is simple quoting. The gdb command:
1098 will fill in argv with the three args "a", "b c d", "e". */
1100 breakup_args (char *scratch, char **argv)
1102 char *pp, *cp = scratch;
1107 /* Scan past leading separators. */
1109 while (*cp == ' ' || *cp == '\t' || *cp == '\n')
1112 /* Break if at end of string. */
1120 quoting = strchr (cp, '"') ? 1 : 0;
1125 /* Scan for next arg separator. */
1128 cp = strchr (pp, '"');
1129 if ((cp == NULL) || (!quoting))
1130 cp = strchr (pp, ' ');
1132 cp = strchr (pp, '\t');
1134 cp = strchr (pp, '\n');
1136 /* No separators => end of string => break. */
1143 /* Replace the separator with a terminator. */
1147 /* Execv requires a null-terminated arg vector. */
1152 procfs_create_inferior (struct target_ops *ops, const char *exec_file,
1153 const std::string &allargs,
1154 char **env, int from_tty)
1156 struct inheritance inherit;
1160 const char *in = "", *out = "", *err = "";
1163 const char *inferior_io_terminal = get_inferior_io_terminal ();
1164 struct inferior *inf;
1166 argv = xmalloc ((allargs.size () / (unsigned) 2 + 2) *
1168 argv[0] = get_exec_file (1);
1172 argv[0] = exec_file;
1177 args = xstrdup (allargs.c_str ());
1178 breakup_args (args, (exec_file != NULL) ? &argv[1] : &argv[0]);
1180 argv = nto_parse_redirection (argv, &in, &out, &err);
1182 fds[0] = STDIN_FILENO;
1183 fds[1] = STDOUT_FILENO;
1184 fds[2] = STDERR_FILENO;
1186 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1187 if the i/o is not also being specified via redirection. */
1188 if (inferior_io_terminal)
1191 in = inferior_io_terminal;
1193 out = inferior_io_terminal;
1195 err = inferior_io_terminal;
1200 fd = open (in, O_RDONLY);
1208 fd = open (out, O_WRONLY);
1216 fd = open (err, O_WRONLY);
1223 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1224 signal (SIGUSR1, signal (SIGUSR1, SIG_IGN));
1227 sigaddset (&set, SIGUSR1);
1228 sigprocmask (SIG_UNBLOCK, &set, NULL);
1230 memset (&inherit, 0, sizeof (inherit));
1232 if (ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) != 0)
1234 inherit.nd = nto_node ();
1235 inherit.flags |= SPAWN_SETND;
1236 inherit.flags &= ~SPAWN_EXEC;
1238 inherit.flags |= SPAWN_SETGROUP | SPAWN_HOLD;
1239 inherit.pgroup = SPAWN_NEWPGROUP;
1240 pid = spawnp (argv[0], 3, fds, &inherit, argv,
1241 ND_NODE_CMP (nto_procfs_node, ND_LOCAL_NODE) == 0 ? env : 0);
1244 sigprocmask (SIG_BLOCK, &set, NULL);
1247 error (_("Error spawning %s: %d (%s)"), argv[0], errno,
1248 safe_strerror (errno));
1250 if (fds[0] != STDIN_FILENO)
1252 if (fds[1] != STDOUT_FILENO)
1254 if (fds[2] != STDERR_FILENO)
1257 inferior_ptid = do_attach (pid_to_ptid (pid));
1258 procfs_update_thread_list (ops);
1260 inf = current_inferior ();
1261 inferior_appeared (inf, pid);
1262 inf->attach_flag = 0;
1264 flags = _DEBUG_FLAG_KLC; /* Kill-on-Last-Close flag. */
1265 errn = devctl (ctl_fd, DCMD_PROC_SET_FLAG, &flags, sizeof (flags), 0);
1268 /* FIXME: expected warning? */
1269 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1270 errn, strerror(errn) ); */
1272 if (!target_is_pushed (ops))
1274 target_terminal::init ();
1276 if (exec_bfd != NULL
1277 || (symfile_objfile != NULL && symfile_objfile->obfd != NULL))
1278 solib_create_inferior_hook (0);
1282 procfs_interrupt (struct target_ops *self, ptid_t ptid)
1284 devctl (ctl_fd, DCMD_PROC_STOP, NULL, 0, 0);
1288 procfs_kill_inferior (struct target_ops *ops)
1290 target_mourn_inferior (inferior_ptid);
1293 /* Fill buf with regset and return devctl cmd to do the setting. Return
1294 -1 if we fail to get the regset. Store size of regset in regsize. */
1296 get_regset (int regset, char *buf, int bufsize, int *regsize)
1298 int dev_get, dev_set;
1301 case NTO_REG_GENERAL:
1302 dev_get = DCMD_PROC_GETGREG;
1303 dev_set = DCMD_PROC_SETGREG;
1307 dev_get = DCMD_PROC_GETFPREG;
1308 dev_set = DCMD_PROC_SETFPREG;
1312 dev_get = DCMD_PROC_GETALTREG;
1313 dev_set = DCMD_PROC_SETALTREG;
1316 case NTO_REG_SYSTEM:
1320 if (devctl (ctl_fd, dev_get, buf, bufsize, regsize) != EOK)
1327 procfs_store_registers (struct target_ops *ops,
1328 struct regcache *regcache, int regno)
1334 procfs_altreg altreg;
1338 int len, regset, regsize, dev_set, err;
1340 ptid_t ptid = regcache_get_ptid (regcache);
1342 if (ptid_equal (ptid, null_ptid))
1344 procfs_set_thread (ptid);
1348 for (regset = NTO_REG_GENERAL; regset < NTO_REG_END; regset++)
1350 dev_set = get_regset (regset, (char *) ®,
1351 sizeof (reg), ®size);
1355 if (nto_regset_fill (regcache, regset, (char *) ®) == -1)
1358 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1360 fprintf_unfiltered (gdb_stderr,
1361 "Warning unable to write regset %d: %s\n",
1362 regno, safe_strerror (err));
1367 regset = nto_regset_id (regno);
1371 dev_set = get_regset (regset, (char *) ®, sizeof (reg), ®size);
1375 len = nto_register_area (regcache->arch (),
1376 regno, regset, &off);
1381 regcache_raw_collect (regcache, regno, (char *) ® + off);
1383 err = devctl (ctl_fd, dev_set, ®, regsize, 0);
1385 fprintf_unfiltered (gdb_stderr,
1386 "Warning unable to write regset %d: %s\n", regno,
1387 safe_strerror (err));
1391 /* Set list of signals to be handled in the target. */
1394 procfs_pass_signals (struct target_ops *self,
1395 int numsigs, unsigned char *pass_signals)
1399 sigfillset (&run.trace);
1401 for (signo = 1; signo < NSIG; signo++)
1403 int target_signo = gdb_signal_from_host (signo);
1404 if (target_signo < numsigs && pass_signals[target_signo])
1405 sigdelset (&run.trace, signo);
1410 procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
1412 static char buf[1024];
1414 struct tidinfo *tip;
1416 pid = ptid_get_pid (ptid);
1417 tid = ptid_get_tid (ptid);
1419 n = snprintf (buf, 1023, "process %d", pid);
1422 tip = procfs_thread_info (pid, tid);
1424 snprintf (&buf[n], 1023, " (state = 0x%02x)", tip->state);
1430 /* to_can_run implementation for "target procfs". Note this really
1431 means "can this target be the default run target", which there can
1432 be only one, and we make it be "target native" like other ports.
1433 "target procfs <node>" wouldn't make sense as default run target, as
1437 procfs_can_run (struct target_ops *self)
1442 /* "target procfs". */
1443 static struct target_ops nto_procfs_ops;
1445 /* "target native". */
1446 static struct target_ops *nto_native_ops;
1448 /* to_open implementation for "target procfs". */
1451 procfs_open (const char *arg, int from_tty)
1453 procfs_open_1 (&nto_procfs_ops, arg, from_tty);
1456 /* to_open implementation for "target native". */
1459 procfs_native_open (const char *arg, int from_tty)
1461 procfs_open_1 (nto_native_ops, arg, from_tty);
1464 /* Create the "native" and "procfs" targets. */
1467 init_procfs_targets (void)
1469 struct target_ops *t = inf_child_target ();
1471 /* Leave to_shortname as "native". */
1472 t->to_longname = "QNX Neutrino local process";
1473 t->to_doc = "QNX Neutrino local process (started by the \"run\" command).";
1474 t->to_open = procfs_native_open;
1475 t->to_attach = procfs_attach;
1476 t->to_post_attach = procfs_post_attach;
1477 t->to_detach = procfs_detach;
1478 t->to_resume = procfs_resume;
1479 t->to_wait = procfs_wait;
1480 t->to_fetch_registers = procfs_fetch_registers;
1481 t->to_store_registers = procfs_store_registers;
1482 t->to_xfer_partial = procfs_xfer_partial;
1483 t->to_files_info = procfs_files_info;
1484 t->to_insert_breakpoint = procfs_insert_breakpoint;
1485 t->to_remove_breakpoint = procfs_remove_breakpoint;
1486 t->to_can_use_hw_breakpoint = procfs_can_use_hw_breakpoint;
1487 t->to_insert_hw_breakpoint = procfs_insert_hw_breakpoint;
1488 t->to_remove_hw_breakpoint = procfs_remove_hw_breakpoint;
1489 t->to_insert_watchpoint = procfs_insert_hw_watchpoint;
1490 t->to_remove_watchpoint = procfs_remove_hw_watchpoint;
1491 t->to_stopped_by_watchpoint = procfs_stopped_by_watchpoint;
1492 t->to_kill = procfs_kill_inferior;
1493 t->to_create_inferior = procfs_create_inferior;
1494 t->to_mourn_inferior = procfs_mourn_inferior;
1495 t->to_pass_signals = procfs_pass_signals;
1496 t->to_thread_alive = procfs_thread_alive;
1497 t->to_update_thread_list = procfs_update_thread_list;
1498 t->to_pid_to_str = procfs_pid_to_str;
1499 t->to_interrupt = procfs_interrupt;
1500 t->to_have_continuable_watchpoint = 1;
1501 t->to_extra_thread_info = nto_extra_thread_info;
1502 t->to_pid_to_exec_file = procfs_pid_to_exec_file;
1506 /* Register "target native". This is the default run target. */
1509 /* Register "target procfs <node>". */
1510 nto_procfs_ops = *t;
1511 nto_procfs_ops.to_shortname = "procfs";
1512 nto_procfs_ops.to_can_run = procfs_can_run;
1513 t->to_longname = "QNX Neutrino local or remote process";
1514 t->to_doc = "QNX Neutrino process. target procfs <node>";
1515 t->to_open = procfs_open;
1517 add_target (&nto_procfs_ops);
1520 #define OSTYPE_NTO 1
1523 _initialize_procfs (void)
1527 init_procfs_targets ();
1529 /* We use SIGUSR1 to gain control after we block waiting for a process.
1530 We use sigwaitevent to wait. */
1532 sigaddset (&set, SIGUSR1);
1533 sigprocmask (SIG_BLOCK, &set, NULL);
1535 /* Initially, make sure all signals are reported. */
1536 sigfillset (&run.trace);
1538 /* Stuff some information. */
1539 nto_cpuinfo_flags = SYSPAGE_ENTRY (cpuinfo)->flags;
1540 nto_cpuinfo_valid = 1;
1542 add_info ("pidlist", procfs_pidlist, _("pidlist"));
1543 add_info ("meminfo", procfs_meminfo, _("memory information"));
1545 nto_is_nto_target = procfs_is_nto_target;
1550 procfs_hw_watchpoint (int addr, int len, enum target_hw_bp_type type)
1557 brk.type = _DEBUG_BREAK_RD;
1560 brk.type = _DEBUG_BREAK_RW;
1562 default: /* Modify. */
1563 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1564 brk.type = _DEBUG_BREAK_RW;
1566 brk.type |= _DEBUG_BREAK_HW; /* Always ask for HW. */
1570 errno = devctl (ctl_fd, DCMD_PROC_BREAK, &brk, sizeof (brk), 0);
1573 perror (_("Failed to set hardware watchpoint"));
1580 procfs_can_use_hw_breakpoint (struct target_ops *self,
1582 int cnt, int othertype)
1588 procfs_remove_hw_watchpoint (struct target_ops *self,
1589 CORE_ADDR addr, int len,
1590 enum target_hw_bp_type type,
1591 struct expression *cond)
1593 return procfs_hw_watchpoint (addr, -1, type);
1597 procfs_insert_hw_watchpoint (struct target_ops *self,
1598 CORE_ADDR addr, int len,
1599 enum target_hw_bp_type type,
1600 struct expression *cond)
1602 return procfs_hw_watchpoint (addr, len, type);
1606 procfs_stopped_by_watchpoint (struct target_ops *ops)
1608 /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are
1609 stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode;
1610 future gdb versions will likely run in 'non-stop' mode in which case
1611 we will have to store/examine statuses per thread in question.
1612 Until then, this will work fine. */
1614 struct inferior *inf = current_inferior ();
1615 struct nto_inferior_data *inf_data;
1617 gdb_assert (inf != NULL);
1619 inf_data = nto_inferior_data (inf);
1621 return inf_data->stopped_flags
1622 & (_DEBUG_FLAG_TRACE_RD
1623 | _DEBUG_FLAG_TRACE_WR
1624 | _DEBUG_FLAG_TRACE_MODIFY);