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-2015 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>
37 #include "gdbthread.h"
42 #include "inf-child.h"
43 #include "common/filestuff.h"
46 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
47 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
51 static sighandler_t ofunc
;
53 static procfs_run run
;
55 static ptid_t
do_attach (ptid_t ptid
);
57 static int procfs_can_use_hw_breakpoint (struct target_ops
*self
,
58 enum bptype
, int, int);
60 static int procfs_insert_hw_watchpoint (struct target_ops
*self
,
61 CORE_ADDR addr
, int len
,
62 enum target_hw_bp_type type
,
63 struct expression
*cond
);
65 static int procfs_remove_hw_watchpoint (struct target_ops
*self
,
66 CORE_ADDR addr
, int len
,
67 enum target_hw_bp_type type
,
68 struct expression
*cond
);
70 static int procfs_stopped_by_watchpoint (struct target_ops
*ops
);
72 /* These two globals are only ever set in procfs_open_1, but are
73 referenced elsewhere. 'nto_procfs_node' is a flag used to say
74 whether we are local, or we should get the current node descriptor
75 for the remote QNX node. */
77 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
79 /* Return the current QNX Node, or error out. This is a simple
80 wrapper for the netmgr_strtond() function. The reason this
81 is required is because QNX node descriptors are transient so
82 we have to re-acquire them every time. */
88 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0
92 node
= netmgr_strtond (nodestr
, 0);
94 error (_("Lost the QNX node. Debug session probably over."));
100 procfs_is_nto_target (bfd
*abfd
)
102 return GDB_OSABI_QNXNTO
;
105 /* This is called when we call 'target native' or 'target procfs
106 <arg>' from the (gdb) prompt. For QNX6 (nto), the only valid arg
107 will be a QNX node string, eg: "/net/some_node". If arg is not a
108 valid QNX node, we will default to local. */
110 procfs_open_1 (struct target_ops
*ops
, const char *arg
, int from_tty
)
115 procfs_sysinfo
*sysinfo
;
116 struct cleanup
*cleanups
;
117 char nto_procfs_path
[PATH_MAX
];
119 /* Offer to kill previous inferiors before opening this target. */
120 target_preopen (from_tty
);
122 nto_is_nto_target
= procfs_is_nto_target
;
124 /* Set the default node used for spawning to this one,
125 and only override it if there is a valid arg. */
130 nto_procfs_node
= ND_LOCAL_NODE
;
131 nodestr
= (arg
!= NULL
) ? xstrdup (arg
) : NULL
;
137 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
138 if (nto_procfs_node
== -1)
140 if (errno
== ENOTSUP
)
141 printf_filtered ("QNX Net Manager not found.\n");
142 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
143 errno
, safe_strerror (errno
));
146 nto_procfs_node
= ND_LOCAL_NODE
;
150 if (*(endstr
- 1) == '/')
156 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s",
157 (nodestr
!= NULL
) ? nodestr
: "", "/proc");
159 fd
= open (nto_procfs_path
, O_RDONLY
);
162 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
163 safe_strerror (errno
));
164 error (_("Invalid procfs arg"));
166 cleanups
= make_cleanup_close (fd
);
168 sysinfo
= (void *) buffer
;
169 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, sizeof buffer
, 0) != EOK
)
171 printf_filtered ("Error getting size: %d (%s)\n", errno
,
172 safe_strerror (errno
));
173 error (_("Devctl failed."));
177 total_size
= sysinfo
->total_size
;
178 sysinfo
= alloca (total_size
);
181 printf_filtered ("Memory error: %d (%s)\n", errno
,
182 safe_strerror (errno
));
183 error (_("alloca failed."));
187 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0) != EOK
)
189 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
190 safe_strerror (errno
));
191 error (_("Devctl failed."));
196 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
197 (target_gdbarch ())->arch_name
))
198 error (_("Invalid target CPU."));
202 do_cleanups (cleanups
);
204 inf_child_open_target (ops
, arg
, from_tty
);
205 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
209 procfs_set_thread (ptid_t ptid
)
213 tid
= ptid_get_tid (ptid
);
214 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
217 /* Return nonzero if the thread TH is still alive. */
219 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
223 procfs_status status
;
226 tid
= ptid_get_tid (ptid
);
227 pid
= ptid_get_pid (ptid
);
229 if (kill (pid
, 0) == -1)
233 if ((err
= devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
,
234 &status
, sizeof (status
), 0)) != EOK
)
237 /* Thread is alive or dead but not yet joined,
238 or dead and there is an alive (or dead unjoined) thread with
241 If the tid is not the same as requested, requested tid is dead. */
242 return (status
.tid
== tid
) && (status
.state
!= STATE_DEAD
);
246 update_thread_private_data_name (struct thread_info
*new_thread
,
250 struct private_thread_info
*pti
;
252 gdb_assert (newname
!= NULL
);
253 gdb_assert (new_thread
!= NULL
);
254 newnamelen
= strlen (newname
);
255 if (!new_thread
->priv
)
257 new_thread
->priv
= xmalloc (offsetof (struct private_thread_info
,
260 memcpy (new_thread
->priv
->name
, newname
, newnamelen
+ 1);
262 else if (strcmp (newname
, new_thread
->priv
->name
) != 0)
264 /* Reallocate if neccessary. */
265 int oldnamelen
= strlen (new_thread
->priv
->name
);
267 if (oldnamelen
< newnamelen
)
268 new_thread
->priv
= xrealloc (new_thread
->priv
,
269 offsetof (struct private_thread_info
,
272 memcpy (new_thread
->priv
->name
, newname
, newnamelen
+ 1);
277 update_thread_private_data (struct thread_info
*new_thread
,
278 pthread_t tid
, int state
, int flags
)
280 struct private_thread_info
*pti
;
282 struct _thread_name
*tn
;
283 procfs_threadctl tctl
;
285 #if _NTO_VERSION > 630
286 gdb_assert (new_thread
!= NULL
);
288 if (devctl (ctl_fd
, DCMD_PROC_INFO
, &pidinfo
,
289 sizeof(pidinfo
), 0) != EOK
)
292 memset (&tctl
, 0, sizeof (tctl
));
293 tctl
.cmd
= _NTO_TCTL_NAME
;
294 tn
= (struct _thread_name
*) (&tctl
.data
);
296 /* Fetch name for the given thread. */
298 tn
->name_buf_len
= sizeof (tctl
.data
) - sizeof (*tn
);
299 tn
->new_name_len
= -1; /* Getting, not setting. */
300 if (devctl (ctl_fd
, DCMD_PROC_THREADCTL
, &tctl
, sizeof (tctl
), NULL
) != EOK
)
301 tn
->name_buf
[0] = '\0';
303 tn
->name_buf
[_NTO_THREAD_NAME_MAX
] = '\0';
305 update_thread_private_data_name (new_thread
, tn
->name_buf
);
307 pti
= (struct private_thread_info
*) new_thread
->priv
;
311 #endif /* _NTO_VERSION */
315 procfs_update_thread_list (struct target_ops
*ops
)
317 procfs_status status
;
321 struct thread_info
*new_thread
;
328 pid
= ptid_get_pid (inferior_ptid
);
332 for (tid
= 1;; ++tid
)
334 if (status
.tid
== tid
335 && (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
338 if (status
.tid
!= tid
)
339 /* The reason why this would not be equal is that devctl might have
340 returned different tid, meaning the requested tid no longer exists
341 (e.g. thread exited). */
343 ptid
= ptid_build (pid
, 0, tid
);
344 new_thread
= find_thread_ptid (ptid
);
346 new_thread
= add_thread (ptid
);
347 update_thread_private_data (new_thread
, tid
, status
.state
, 0);
354 do_closedir_cleanup (void *dir
)
360 procfs_pidlist (char *args
, int from_tty
)
363 struct dirent
*dirp
= NULL
;
365 procfs_info
*pidinfo
= NULL
;
366 procfs_debuginfo
*info
= NULL
;
367 procfs_status
*status
= NULL
;
368 pid_t num_threads
= 0;
371 struct cleanup
*cleanups
;
372 char procfs_dir
[PATH_MAX
];
374 snprintf (procfs_dir
, sizeof (procfs_dir
), "%s%s",
375 (nodestr
!= NULL
) ? nodestr
: "", "/proc");
377 dp
= opendir (procfs_dir
);
380 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
381 procfs_dir
, errno
, safe_strerror (errno
));
385 cleanups
= make_cleanup (do_closedir_cleanup
, dp
);
387 /* Start scan at first pid. */
393 struct cleanup
*inner_cleanup
;
395 /* Get the right pid and procfs path for the pid. */
401 do_cleanups (cleanups
);
404 snprintf (buf
, sizeof (buf
), "%s%s/%s/as",
405 (nodestr
!= NULL
) ? nodestr
: "",
406 "/proc", dirp
->d_name
);
407 pid
= atoi (dirp
->d_name
);
411 /* Open the procfs path. */
412 fd
= open (buf
, O_RDONLY
);
415 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
416 buf
, errno
, safe_strerror (errno
));
419 inner_cleanup
= make_cleanup_close (fd
);
421 pidinfo
= (procfs_info
*) buf
;
422 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
424 fprintf_unfiltered (gdb_stderr
,
425 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
426 errno
, safe_strerror (errno
));
429 num_threads
= pidinfo
->num_threads
;
431 info
= (procfs_debuginfo
*) buf
;
432 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
433 strcpy (name
, "unavailable");
435 strcpy (name
, info
->path
);
437 /* Collect state info on all the threads. */
438 status
= (procfs_status
*) buf
;
439 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
442 = devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0);
443 printf_filtered ("%s - %d", name
, pid
);
444 if (err
== EOK
&& status
->tid
!= 0)
445 printf_filtered ("/%d\n", status
->tid
);
448 printf_filtered ("\n");
453 do_cleanups (inner_cleanup
);
455 while (dirp
!= NULL
);
457 do_cleanups (cleanups
);
462 procfs_meminfo (char *args
, int from_tty
)
464 procfs_mapinfo
*mapinfos
= NULL
;
465 static int num_mapinfos
= 0;
466 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
467 int flags
= ~0, err
, num
, i
, j
;
471 procfs_debuginfo info
;
472 char buff
[_POSIX_PATH_MAX
];
480 unsigned debug_vaddr
;
481 unsigned long long offset
;
486 unsigned long long ino
;
493 /* Get the number of map entrys. */
494 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
497 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
498 safe_strerror (err
));
502 mapinfos
= XNEWVEC (procfs_mapinfo
, num
);
505 mapinfo_p
= mapinfos
;
507 /* Fill the map entrys. */
508 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
509 * sizeof (procfs_mapinfo
), &num
);
512 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
517 num
= min (num
, num_mapinfos
);
519 /* Run through the list of mapinfos, and store the data and text info
520 so we can print it at the bottom of the loop. */
521 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
523 if (!(mapinfo_p
->flags
& flags
))
526 if (mapinfo_p
->ino
== 0) /* Already visited. */
529 map
.info
.vaddr
= mapinfo_p
->vaddr
;
531 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
535 memset (&printme
, 0, sizeof printme
);
536 printme
.dev
= mapinfo_p
->dev
;
537 printme
.ino
= mapinfo_p
->ino
;
538 printme
.text
.addr
= mapinfo_p
->vaddr
;
539 printme
.text
.size
= mapinfo_p
->size
;
540 printme
.text
.flags
= mapinfo_p
->flags
;
541 printme
.text
.offset
= mapinfo_p
->offset
;
542 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
543 strcpy (printme
.name
, map
.info
.path
);
545 /* Check for matching data. */
546 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
548 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
549 && mapinfo_p2
->ino
== mapinfo_p
->ino
550 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
552 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
554 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
558 if (strcmp (map
.info
.path
, printme
.name
))
561 /* Lower debug_vaddr is always text, if nessessary, swap. */
562 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
564 memcpy (&(printme
.data
), &(printme
.text
),
565 sizeof (printme
.data
));
566 printme
.text
.addr
= mapinfo_p2
->vaddr
;
567 printme
.text
.size
= mapinfo_p2
->size
;
568 printme
.text
.flags
= mapinfo_p2
->flags
;
569 printme
.text
.offset
= mapinfo_p2
->offset
;
570 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
574 printme
.data
.addr
= mapinfo_p2
->vaddr
;
575 printme
.data
.size
= mapinfo_p2
->size
;
576 printme
.data
.flags
= mapinfo_p2
->flags
;
577 printme
.data
.offset
= mapinfo_p2
->offset
;
578 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
585 printf_filtered ("%s\n", printme
.name
);
586 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
588 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
589 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
590 printf_filtered ("\t\toffset=%s\n", phex (printme
.text
.offset
, 8));
591 if (printme
.data
.size
)
593 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
595 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
596 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
597 printf_filtered ("\t\toffset=%s\n", phex (printme
.data
.offset
, 8));
599 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
600 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
606 /* Print status information about what we're accessing. */
608 procfs_files_info (struct target_ops
*ignore
)
610 struct inferior
*inf
= current_inferior ();
612 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
613 inf
->attach_flag
? "attached" : "child",
614 target_pid_to_str (inferior_ptid
),
615 (nodestr
!= NULL
) ? nodestr
: "local node");
618 /* Attach to process PID, then initialize for debugging it. */
620 procfs_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
624 struct inferior
*inf
;
626 pid
= parse_pid_to_attach (args
);
628 if (pid
== getpid ())
629 error (_("Attaching GDB to itself is not a good idea..."));
633 exec_file
= (char *) get_exec_file (0);
636 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
637 target_pid_to_str (pid_to_ptid (pid
)));
639 printf_unfiltered ("Attaching to %s\n",
640 target_pid_to_str (pid_to_ptid (pid
)));
642 gdb_flush (gdb_stdout
);
644 inferior_ptid
= do_attach (pid_to_ptid (pid
));
645 inf
= current_inferior ();
646 inferior_appeared (inf
, pid
);
647 inf
->attach_flag
= 1;
649 if (!target_is_pushed (ops
))
652 procfs_update_thread_list (ops
);
656 procfs_post_attach (struct target_ops
*self
, pid_t pid
)
659 solib_create_inferior_hook (0);
663 do_attach (ptid_t ptid
)
665 procfs_status status
;
666 struct sigevent event
;
669 snprintf (path
, PATH_MAX
- 1, "%s%s/%d/as",
670 (nodestr
!= NULL
) ? nodestr
: "", "/proc", ptid_get_pid (ptid
));
671 ctl_fd
= open (path
, O_RDWR
);
673 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
674 safe_strerror (errno
));
675 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
676 error (_("Couldn't stop process"));
678 /* Define a sigevent for process stopped notification. */
679 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
680 event
.sigev_signo
= SIGUSR1
;
681 event
.sigev_code
= 0;
682 event
.sigev_value
.sival_ptr
= NULL
;
683 event
.sigev_priority
= -1;
684 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
686 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
687 && status
.flags
& _DEBUG_FLAG_STOPPED
)
688 SignalKill (nto_node (), ptid_get_pid (ptid
), 0, SIGCONT
, 0, 0);
689 nto_init_solib_absolute_prefix ();
690 return ptid_build (ptid_get_pid (ptid
), 0, status
.tid
);
693 /* Ask the user what to do when an interrupt is received. */
695 interrupt_query (void)
697 target_terminal_ours ();
699 if (query (_("Interrupted while waiting for the program.\n\
700 Give up (and stop debugging it)? ")))
702 target_mourn_inferior ();
706 target_terminal_inferior ();
709 /* The user typed ^C twice. */
711 nto_handle_sigint_twice (int signo
)
713 signal (signo
, ofunc
);
715 signal (signo
, nto_handle_sigint_twice
);
719 nto_handle_sigint (int signo
)
721 /* If this doesn't work, try more severe steps. */
722 signal (signo
, nto_handle_sigint_twice
);
724 target_interrupt (inferior_ptid
);
728 procfs_wait (struct target_ops
*ops
,
729 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
733 procfs_status status
;
734 static int exit_signo
= 0; /* To track signals that cause termination. */
736 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
738 if (ptid_equal (inferior_ptid
, null_ptid
))
740 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
741 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
747 sigaddset (&set
, SIGUSR1
);
749 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
750 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
752 ofunc
= signal (SIGINT
, nto_handle_sigint
);
753 sigwaitinfo (&set
, &info
);
754 signal (SIGINT
, ofunc
);
755 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
758 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
760 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
761 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
763 /* Was it a breakpoint? */
764 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
766 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
767 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
769 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
773 case _DEBUG_WHY_SIGNALLED
:
774 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
775 ourstatus
->value
.sig
=
776 gdb_signal_from_host (status
.info
.si_signo
);
779 case _DEBUG_WHY_FAULTED
:
780 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
781 if (status
.info
.si_signo
== SIGTRAP
)
783 ourstatus
->value
.sig
= 0;
788 ourstatus
->value
.sig
=
789 gdb_signal_from_host (status
.info
.si_signo
);
790 exit_signo
= ourstatus
->value
.sig
;
794 case _DEBUG_WHY_TERMINATED
:
798 waitpid (ptid_get_pid (inferior_ptid
), &waitval
, WNOHANG
);
801 /* Abnormal death. */
802 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
803 ourstatus
->value
.sig
= exit_signo
;
808 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
809 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
815 case _DEBUG_WHY_REQUESTED
:
816 /* We are assuming a requested stop is due to a SIGINT. */
817 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
818 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
824 return ptid_build (status
.pid
, 0, status
.tid
);
827 /* Read the current values of the inferior's registers, both the
828 general register set and floating point registers (if supported)
829 and update gdb's idea of their current values. */
831 procfs_fetch_registers (struct target_ops
*ops
,
832 struct regcache
*regcache
, int regno
)
838 procfs_altreg altreg
;
843 procfs_set_thread (inferior_ptid
);
844 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
845 nto_supply_gregset (regcache
, (char *) ®
.greg
);
846 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
848 nto_supply_fpregset (regcache
, (char *) ®
.fpreg
);
849 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
851 nto_supply_altregset (regcache
, (char *) ®
.altreg
);
854 /* Helper for procfs_xfer_partial that handles memory transfers.
855 Arguments are like target_xfer_partial. */
857 static enum target_xfer_status
858 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
859 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
863 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
864 return TARGET_XFER_E_IO
;
866 if (writebuf
!= NULL
)
867 nbytes
= write (ctl_fd
, writebuf
, len
);
869 nbytes
= read (ctl_fd
, readbuf
, len
);
871 return TARGET_XFER_E_IO
;
872 *xfered_len
= nbytes
;
873 return TARGET_XFER_OK
;
876 /* Target to_xfer_partial implementation. */
878 static enum target_xfer_status
879 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
880 const char *annex
, gdb_byte
*readbuf
,
881 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
882 ULONGEST
*xfered_len
)
886 case TARGET_OBJECT_MEMORY
:
887 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
889 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
890 readbuf
, writebuf
, offset
, len
,
895 /* Take a program previously attached to and detaches it.
896 The program resumes execution and will no longer stop
897 on signals, etc. We'd better not have left any breakpoints
898 in the program or it'll die when it hits one. */
900 procfs_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
907 char *exec_file
= get_exec_file (0);
910 printf_unfiltered ("Detaching from program: %s %s\n",
911 exec_file
, target_pid_to_str (inferior_ptid
));
912 gdb_flush (gdb_stdout
);
915 siggnal
= atoi (args
);
918 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, siggnal
, 0, 0);
923 pid
= ptid_get_pid (inferior_ptid
);
924 inferior_ptid
= null_ptid
;
925 detach_inferior (pid
);
927 inf_child_maybe_unpush_target (ops
);
931 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
938 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
945 procfs_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
946 struct bp_target_info
*bp_tgt
)
948 bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
949 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, 0);
953 procfs_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
954 struct bp_target_info
*bp_tgt
)
956 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, -1);
960 procfs_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
961 struct bp_target_info
*bp_tgt
)
963 bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
964 return procfs_breakpoint (bp_tgt
->placed_address
,
965 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
969 procfs_remove_hw_breakpoint (struct target_ops
*self
,
970 struct gdbarch
*gdbarch
,
971 struct bp_target_info
*bp_tgt
)
973 return procfs_breakpoint (bp_tgt
->placed_address
,
974 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
978 procfs_resume (struct target_ops
*ops
,
979 ptid_t ptid
, int step
, enum gdb_signal signo
)
982 procfs_status status
;
983 sigset_t
*run_fault
= (sigset_t
*) (void *) &run
.fault
;
985 if (ptid_equal (inferior_ptid
, null_ptid
))
988 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
991 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
993 run
.flags
|= _DEBUG_RUN_STEP
;
995 sigemptyset (run_fault
);
996 sigaddset (run_fault
, FLTBPT
);
997 sigaddset (run_fault
, FLTTRACE
);
998 sigaddset (run_fault
, FLTILL
);
999 sigaddset (run_fault
, FLTPRIV
);
1000 sigaddset (run_fault
, FLTBOUNDS
);
1001 sigaddset (run_fault
, FLTIOVF
);
1002 sigaddset (run_fault
, FLTIZDIV
);
1003 sigaddset (run_fault
, FLTFPE
);
1004 /* Peter V will be changing this at some point. */
1005 sigaddset (run_fault
, FLTPAGE
);
1007 run
.flags
|= _DEBUG_RUN_ARM
;
1009 signal_to_pass
= gdb_signal_to_host (signo
);
1013 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
1014 signal_to_pass
= gdb_signal_to_host (signo
);
1015 if (status
.why
& (_DEBUG_WHY_SIGNALLED
| _DEBUG_WHY_FAULTED
))
1017 if (signal_to_pass
!= status
.info
.si_signo
)
1019 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0,
1020 signal_to_pass
, 0, 0);
1021 run
.flags
|= _DEBUG_RUN_CLRFLT
| _DEBUG_RUN_CLRSIG
;
1023 else /* Let it kill the program without telling us. */
1024 sigdelset (&run
.trace
, signal_to_pass
);
1028 run
.flags
|= _DEBUG_RUN_CLRSIG
| _DEBUG_RUN_CLRFLT
;
1030 errno
= devctl (ctl_fd
, DCMD_PROC_RUN
, &run
, sizeof (run
), 0);
1033 perror (_("run error!\n"));
1039 procfs_mourn_inferior (struct target_ops
*ops
)
1041 if (!ptid_equal (inferior_ptid
, null_ptid
))
1043 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, SIGKILL
, 0, 0);
1046 inferior_ptid
= null_ptid
;
1047 init_thread_list ();
1048 inf_child_mourn_inferior (ops
);
1051 /* This function breaks up an argument string into an argument
1052 vector suitable for passing to execvp().
1053 E.g., on "run a b c d" this routine would get as input
1054 the string "a b c d", and as output it would fill in argv with
1055 the four arguments "a", "b", "c", "d". The only additional
1056 functionality is simple quoting. The gdb command:
1058 will fill in argv with the three args "a", "b c d", "e". */
1060 breakup_args (char *scratch
, char **argv
)
1062 char *pp
, *cp
= scratch
;
1067 /* Scan past leading separators. */
1069 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
1072 /* Break if at end of string. */
1080 quoting
= strchr (cp
, '"') ? 1 : 0;
1085 /* Scan for next arg separator. */
1088 cp
= strchr (pp
, '"');
1089 if ((cp
== NULL
) || (!quoting
))
1090 cp
= strchr (pp
, ' ');
1092 cp
= strchr (pp
, '\t');
1094 cp
= strchr (pp
, '\n');
1096 /* No separators => end of string => break. */
1103 /* Replace the separator with a terminator. */
1107 /* Execv requires a null-terminated arg vector. */
1112 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
1113 char *allargs
, char **env
, int from_tty
)
1115 struct inheritance inherit
;
1119 const char *in
= "", *out
= "", *err
= "";
1122 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1123 struct inferior
*inf
;
1125 argv
= xmalloc (((strlen (allargs
) + 1) / (unsigned) 2 + 2) *
1127 argv
[0] = get_exec_file (1);
1131 argv
[0] = exec_file
;
1136 args
= xstrdup (allargs
);
1137 breakup_args (args
, (exec_file
!= NULL
) ? &argv
[1] : &argv
[0]);
1139 argv
= nto_parse_redirection (argv
, &in
, &out
, &err
);
1141 fds
[0] = STDIN_FILENO
;
1142 fds
[1] = STDOUT_FILENO
;
1143 fds
[2] = STDERR_FILENO
;
1145 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1146 if the i/o is not also being specified via redirection. */
1147 if (inferior_io_terminal
)
1150 in
= inferior_io_terminal
;
1152 out
= inferior_io_terminal
;
1154 err
= inferior_io_terminal
;
1159 fd
= open (in
, O_RDONLY
);
1167 fd
= open (out
, O_WRONLY
);
1175 fd
= open (err
, O_WRONLY
);
1182 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1183 signal (SIGUSR1
, signal (SIGUSR1
, SIG_IGN
));
1186 sigaddset (&set
, SIGUSR1
);
1187 sigprocmask (SIG_UNBLOCK
, &set
, NULL
);
1189 memset (&inherit
, 0, sizeof (inherit
));
1191 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) != 0)
1193 inherit
.nd
= nto_node ();
1194 inherit
.flags
|= SPAWN_SETND
;
1195 inherit
.flags
&= ~SPAWN_EXEC
;
1197 inherit
.flags
|= SPAWN_SETGROUP
| SPAWN_HOLD
;
1198 inherit
.pgroup
= SPAWN_NEWPGROUP
;
1199 pid
= spawnp (argv
[0], 3, fds
, &inherit
, argv
,
1200 ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0 ? env
: 0);
1203 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1206 error (_("Error spawning %s: %d (%s)"), argv
[0], errno
,
1207 safe_strerror (errno
));
1209 if (fds
[0] != STDIN_FILENO
)
1211 if (fds
[1] != STDOUT_FILENO
)
1213 if (fds
[2] != STDERR_FILENO
)
1216 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1217 procfs_update_thread_list (ops
);
1219 inf
= current_inferior ();
1220 inferior_appeared (inf
, pid
);
1221 inf
->attach_flag
= 0;
1223 flags
= _DEBUG_FLAG_KLC
; /* Kill-on-Last-Close flag. */
1224 errn
= devctl (ctl_fd
, DCMD_PROC_SET_FLAG
, &flags
, sizeof (flags
), 0);
1227 /* FIXME: expected warning? */
1228 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1229 errn, strerror(errn) ); */
1231 if (!target_is_pushed (ops
))
1233 target_terminal_init ();
1235 if (exec_bfd
!= NULL
1236 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1237 solib_create_inferior_hook (0);
1241 procfs_interrupt (struct target_ops
*self
, ptid_t ptid
)
1243 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1247 procfs_kill_inferior (struct target_ops
*ops
)
1249 target_mourn_inferior ();
1252 /* Fill buf with regset and return devctl cmd to do the setting. Return
1253 -1 if we fail to get the regset. Store size of regset in regsize. */
1255 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1257 int dev_get
, dev_set
;
1260 case NTO_REG_GENERAL
:
1261 dev_get
= DCMD_PROC_GETGREG
;
1262 dev_set
= DCMD_PROC_SETGREG
;
1266 dev_get
= DCMD_PROC_GETFPREG
;
1267 dev_set
= DCMD_PROC_SETFPREG
;
1271 dev_get
= DCMD_PROC_GETALTREG
;
1272 dev_set
= DCMD_PROC_SETALTREG
;
1275 case NTO_REG_SYSTEM
:
1279 if (devctl (ctl_fd
, dev_get
, buf
, bufsize
, regsize
) != EOK
)
1286 procfs_store_registers (struct target_ops
*ops
,
1287 struct regcache
*regcache
, int regno
)
1293 procfs_altreg altreg
;
1297 int len
, regset
, regsize
, dev_set
, err
;
1300 if (ptid_equal (inferior_ptid
, null_ptid
))
1302 procfs_set_thread (inferior_ptid
);
1306 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1308 dev_set
= get_regset (regset
, (char *) ®
,
1309 sizeof (reg
), ®size
);
1313 if (nto_regset_fill (regcache
, regset
, (char *) ®
) == -1)
1316 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1318 fprintf_unfiltered (gdb_stderr
,
1319 "Warning unable to write regset %d: %s\n",
1320 regno
, safe_strerror (err
));
1325 regset
= nto_regset_id (regno
);
1329 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1333 len
= nto_register_area (get_regcache_arch (regcache
),
1334 regno
, regset
, &off
);
1339 regcache_raw_collect (regcache
, regno
, (char *) ®
+ off
);
1341 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1343 fprintf_unfiltered (gdb_stderr
,
1344 "Warning unable to write regset %d: %s\n", regno
,
1345 safe_strerror (err
));
1349 /* Set list of signals to be handled in the target. */
1352 procfs_pass_signals (struct target_ops
*self
,
1353 int numsigs
, unsigned char *pass_signals
)
1357 sigfillset (&run
.trace
);
1359 for (signo
= 1; signo
< NSIG
; signo
++)
1361 int target_signo
= gdb_signal_from_host (signo
);
1362 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
1363 sigdelset (&run
.trace
, signo
);
1368 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1370 static char buf
[1024];
1372 struct tidinfo
*tip
;
1374 pid
= ptid_get_pid (ptid
);
1375 tid
= ptid_get_tid (ptid
);
1377 n
= snprintf (buf
, 1023, "process %d", pid
);
1380 tip
= procfs_thread_info (pid
, tid
);
1382 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1388 /* to_can_run implementation for "target procfs". Note this really
1389 means "can this target be the default run target", which there can
1390 be only one, and we make it be "target native" like other ports.
1391 "target procfs <node>" wouldn't make sense as default run target, as
1395 procfs_can_run (struct target_ops
*self
)
1400 /* "target procfs". */
1401 static struct target_ops nto_procfs_ops
;
1403 /* "target native". */
1404 static struct target_ops
*nto_native_ops
;
1406 /* to_open implementation for "target procfs". */
1409 procfs_open (const char *arg
, int from_tty
)
1411 procfs_open_1 (&nto_procfs_ops
, arg
, from_tty
);
1414 /* to_open implementation for "target native". */
1417 procfs_native_open (const char *arg
, int from_tty
)
1419 procfs_open_1 (nto_native_ops
, arg
, from_tty
);
1422 /* Create the "native" and "procfs" targets. */
1425 init_procfs_targets (void)
1427 struct target_ops
*t
= inf_child_target ();
1429 /* Leave to_shortname as "native". */
1430 t
->to_longname
= "QNX Neutrino local process";
1431 t
->to_doc
= "QNX Neutrino local process (started by the \"run\" command).";
1432 t
->to_open
= procfs_native_open
;
1433 t
->to_attach
= procfs_attach
;
1434 t
->to_post_attach
= procfs_post_attach
;
1435 t
->to_detach
= procfs_detach
;
1436 t
->to_resume
= procfs_resume
;
1437 t
->to_wait
= procfs_wait
;
1438 t
->to_fetch_registers
= procfs_fetch_registers
;
1439 t
->to_store_registers
= procfs_store_registers
;
1440 t
->to_xfer_partial
= procfs_xfer_partial
;
1441 t
->to_files_info
= procfs_files_info
;
1442 t
->to_insert_breakpoint
= procfs_insert_breakpoint
;
1443 t
->to_remove_breakpoint
= procfs_remove_breakpoint
;
1444 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
1445 t
->to_insert_hw_breakpoint
= procfs_insert_hw_breakpoint
;
1446 t
->to_remove_hw_breakpoint
= procfs_remove_hw_breakpoint
;
1447 t
->to_insert_watchpoint
= procfs_insert_hw_watchpoint
;
1448 t
->to_remove_watchpoint
= procfs_remove_hw_watchpoint
;
1449 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
1450 t
->to_kill
= procfs_kill_inferior
;
1451 t
->to_create_inferior
= procfs_create_inferior
;
1452 t
->to_mourn_inferior
= procfs_mourn_inferior
;
1453 t
->to_pass_signals
= procfs_pass_signals
;
1454 t
->to_thread_alive
= procfs_thread_alive
;
1455 t
->to_update_thread_list
= procfs_update_thread_list
;
1456 t
->to_pid_to_str
= procfs_pid_to_str
;
1457 t
->to_interrupt
= procfs_interrupt
;
1458 t
->to_have_continuable_watchpoint
= 1;
1459 t
->to_extra_thread_info
= nto_extra_thread_info
;
1463 /* Register "target native". This is the default run target. */
1466 /* Register "target procfs <node>". */
1467 nto_procfs_ops
= *t
;
1468 nto_procfs_ops
.to_shortname
= "procfs";
1469 nto_procfs_ops
.to_can_run
= procfs_can_run
;
1470 t
->to_longname
= "QNX Neutrino local or remote process";
1471 t
->to_doc
= "QNX Neutrino process. target procfs <node>";
1472 t
->to_open
= procfs_open
;
1474 add_target (&nto_procfs_ops
);
1477 #define OSTYPE_NTO 1
1479 extern initialize_file_ftype _initialize_procfs
;
1482 _initialize_procfs (void)
1486 init_procfs_targets ();
1488 /* We use SIGUSR1 to gain control after we block waiting for a process.
1489 We use sigwaitevent to wait. */
1491 sigaddset (&set
, SIGUSR1
);
1492 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1494 /* Initially, make sure all signals are reported. */
1495 sigfillset (&run
.trace
);
1497 /* Stuff some information. */
1498 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1499 nto_cpuinfo_valid
= 1;
1501 add_info ("pidlist", procfs_pidlist
, _("pidlist"));
1502 add_info ("meminfo", procfs_meminfo
, _("memory information"));
1504 nto_is_nto_target
= procfs_is_nto_target
;
1509 procfs_hw_watchpoint (int addr
, int len
, enum target_hw_bp_type type
)
1516 brk
.type
= _DEBUG_BREAK_RD
;
1519 brk
.type
= _DEBUG_BREAK_RW
;
1521 default: /* Modify. */
1522 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1523 brk
.type
= _DEBUG_BREAK_RW
;
1525 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1529 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1532 perror (_("Failed to set hardware watchpoint"));
1539 procfs_can_use_hw_breakpoint (struct target_ops
*self
,
1541 int cnt
, int othertype
)
1547 procfs_remove_hw_watchpoint (struct target_ops
*self
,
1548 CORE_ADDR addr
, int len
,
1549 enum target_hw_bp_type type
,
1550 struct expression
*cond
)
1552 return procfs_hw_watchpoint (addr
, -1, type
);
1556 procfs_insert_hw_watchpoint (struct target_ops
*self
,
1557 CORE_ADDR addr
, int len
,
1558 enum target_hw_bp_type type
,
1559 struct expression
*cond
)
1561 return procfs_hw_watchpoint (addr
, len
, type
);
1565 procfs_stopped_by_watchpoint (struct target_ops
*ops
)