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-2016 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
,
252 struct private_thread_info
*pti
;
254 gdb_assert (newname
!= NULL
);
255 gdb_assert (new_thread
!= NULL
);
256 newnamelen
= strlen (newname
);
257 if (!new_thread
->priv
)
259 new_thread
->priv
= xmalloc (offsetof (struct private_thread_info
,
262 memcpy (new_thread
->priv
->name
, newname
, newnamelen
+ 1);
264 else if (strcmp (newname
, new_thread
->priv
->name
) != 0)
266 /* Reallocate if neccessary. */
267 int oldnamelen
= strlen (new_thread
->priv
->name
);
269 if (oldnamelen
< newnamelen
)
270 new_thread
->priv
= xrealloc (new_thread
->priv
,
271 offsetof (struct private_thread_info
,
274 memcpy (new_thread
->priv
->name
, newname
, newnamelen
+ 1);
279 update_thread_private_data (struct thread_info
*new_thread
,
280 pthread_t tid
, int state
, int flags
)
282 struct private_thread_info
*pti
;
284 struct _thread_name
*tn
;
285 procfs_threadctl tctl
;
287 #if _NTO_VERSION > 630
288 gdb_assert (new_thread
!= NULL
);
290 if (devctl (ctl_fd
, DCMD_PROC_INFO
, &pidinfo
,
291 sizeof(pidinfo
), 0) != EOK
)
294 memset (&tctl
, 0, sizeof (tctl
));
295 tctl
.cmd
= _NTO_TCTL_NAME
;
296 tn
= (struct _thread_name
*) (&tctl
.data
);
298 /* Fetch name for the given thread. */
300 tn
->name_buf_len
= sizeof (tctl
.data
) - sizeof (*tn
);
301 tn
->new_name_len
= -1; /* Getting, not setting. */
302 if (devctl (ctl_fd
, DCMD_PROC_THREADCTL
, &tctl
, sizeof (tctl
), NULL
) != EOK
)
303 tn
->name_buf
[0] = '\0';
305 tn
->name_buf
[_NTO_THREAD_NAME_MAX
] = '\0';
307 update_thread_private_data_name (new_thread
, tn
->name_buf
);
309 pti
= (struct private_thread_info
*) new_thread
->priv
;
313 #endif /* _NTO_VERSION */
317 procfs_update_thread_list (struct target_ops
*ops
)
319 procfs_status status
;
323 struct thread_info
*new_thread
;
330 pid
= ptid_get_pid (inferior_ptid
);
334 for (tid
= 1;; ++tid
)
336 if (status
.tid
== tid
337 && (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
340 if (status
.tid
!= tid
)
341 /* The reason why this would not be equal is that devctl might have
342 returned different tid, meaning the requested tid no longer exists
343 (e.g. thread exited). */
345 ptid
= ptid_build (pid
, 0, tid
);
346 new_thread
= find_thread_ptid (ptid
);
348 new_thread
= add_thread (ptid
);
349 update_thread_private_data (new_thread
, tid
, status
.state
, 0);
356 do_closedir_cleanup (void *dir
)
362 procfs_pidlist (char *args
, int from_tty
)
365 struct dirent
*dirp
= NULL
;
367 procfs_info
*pidinfo
= NULL
;
368 procfs_debuginfo
*info
= NULL
;
369 procfs_status
*status
= NULL
;
370 pid_t num_threads
= 0;
373 struct cleanup
*cleanups
;
374 char procfs_dir
[PATH_MAX
];
376 snprintf (procfs_dir
, sizeof (procfs_dir
), "%s%s",
377 (nodestr
!= NULL
) ? nodestr
: "", "/proc");
379 dp
= opendir (procfs_dir
);
382 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
383 procfs_dir
, errno
, safe_strerror (errno
));
387 cleanups
= make_cleanup (do_closedir_cleanup
, dp
);
389 /* Start scan at first pid. */
395 struct cleanup
*inner_cleanup
;
397 /* Get the right pid and procfs path for the pid. */
403 do_cleanups (cleanups
);
406 snprintf (buf
, sizeof (buf
), "%s%s/%s/as",
407 (nodestr
!= NULL
) ? nodestr
: "",
408 "/proc", dirp
->d_name
);
409 pid
= atoi (dirp
->d_name
);
413 /* Open the procfs path. */
414 fd
= open (buf
, O_RDONLY
);
417 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
418 buf
, errno
, safe_strerror (errno
));
421 inner_cleanup
= make_cleanup_close (fd
);
423 pidinfo
= (procfs_info
*) buf
;
424 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
426 fprintf_unfiltered (gdb_stderr
,
427 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
428 errno
, safe_strerror (errno
));
431 num_threads
= pidinfo
->num_threads
;
433 info
= (procfs_debuginfo
*) buf
;
434 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
435 strcpy (name
, "unavailable");
437 strcpy (name
, info
->path
);
439 /* Collect state info on all the threads. */
440 status
= (procfs_status
*) buf
;
441 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
444 = devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0);
445 printf_filtered ("%s - %d", name
, pid
);
446 if (err
== EOK
&& status
->tid
!= 0)
447 printf_filtered ("/%d\n", status
->tid
);
450 printf_filtered ("\n");
455 do_cleanups (inner_cleanup
);
457 while (dirp
!= NULL
);
459 do_cleanups (cleanups
);
464 procfs_meminfo (char *args
, int from_tty
)
466 procfs_mapinfo
*mapinfos
= NULL
;
467 static int num_mapinfos
= 0;
468 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
469 int flags
= ~0, err
, num
, i
, j
;
473 procfs_debuginfo info
;
474 char buff
[_POSIX_PATH_MAX
];
482 unsigned debug_vaddr
;
483 unsigned long long offset
;
488 unsigned long long ino
;
495 /* Get the number of map entrys. */
496 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
499 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
500 safe_strerror (err
));
504 mapinfos
= XNEWVEC (procfs_mapinfo
, num
);
507 mapinfo_p
= mapinfos
;
509 /* Fill the map entrys. */
510 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
511 * sizeof (procfs_mapinfo
), &num
);
514 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
519 num
= min (num
, num_mapinfos
);
521 /* Run through the list of mapinfos, and store the data and text info
522 so we can print it at the bottom of the loop. */
523 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
525 if (!(mapinfo_p
->flags
& flags
))
528 if (mapinfo_p
->ino
== 0) /* Already visited. */
531 map
.info
.vaddr
= mapinfo_p
->vaddr
;
533 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
537 memset (&printme
, 0, sizeof printme
);
538 printme
.dev
= mapinfo_p
->dev
;
539 printme
.ino
= mapinfo_p
->ino
;
540 printme
.text
.addr
= mapinfo_p
->vaddr
;
541 printme
.text
.size
= mapinfo_p
->size
;
542 printme
.text
.flags
= mapinfo_p
->flags
;
543 printme
.text
.offset
= mapinfo_p
->offset
;
544 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
545 strcpy (printme
.name
, map
.info
.path
);
547 /* Check for matching data. */
548 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
550 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
551 && mapinfo_p2
->ino
== mapinfo_p
->ino
552 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
554 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
556 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
560 if (strcmp (map
.info
.path
, printme
.name
))
563 /* Lower debug_vaddr is always text, if nessessary, swap. */
564 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
566 memcpy (&(printme
.data
), &(printme
.text
),
567 sizeof (printme
.data
));
568 printme
.text
.addr
= mapinfo_p2
->vaddr
;
569 printme
.text
.size
= mapinfo_p2
->size
;
570 printme
.text
.flags
= mapinfo_p2
->flags
;
571 printme
.text
.offset
= mapinfo_p2
->offset
;
572 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
576 printme
.data
.addr
= mapinfo_p2
->vaddr
;
577 printme
.data
.size
= mapinfo_p2
->size
;
578 printme
.data
.flags
= mapinfo_p2
->flags
;
579 printme
.data
.offset
= mapinfo_p2
->offset
;
580 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
587 printf_filtered ("%s\n", printme
.name
);
588 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
590 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
591 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
592 printf_filtered ("\t\toffset=%s\n", phex (printme
.text
.offset
, 8));
593 if (printme
.data
.size
)
595 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
597 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
598 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
599 printf_filtered ("\t\toffset=%s\n", phex (printme
.data
.offset
, 8));
601 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
602 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
608 /* Print status information about what we're accessing. */
610 procfs_files_info (struct target_ops
*ignore
)
612 struct inferior
*inf
= current_inferior ();
614 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
615 inf
->attach_flag
? "attached" : "child",
616 target_pid_to_str (inferior_ptid
),
617 (nodestr
!= NULL
) ? nodestr
: "local node");
620 /* Target to_pid_to_exec_file implementation. */
623 procfs_pid_to_exec_file (struct target_ops
*ops
, const int pid
)
626 static char proc_path
[PATH_MAX
];
629 /* Read exe file name. */
630 snprintf (proc_path
, sizeof (proc_path
), "%s/proc/%d/exefile",
631 (nodestr
!= NULL
) ? nodestr
: "", pid
);
632 proc_fd
= open (proc_path
, O_RDONLY
);
636 rd
= read (proc_fd
, proc_path
, sizeof (proc_path
) - 1);
643 proc_path
[rd
] = '\0';
647 /* Attach to process PID, then initialize for debugging it. */
649 procfs_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
653 struct inferior
*inf
;
655 pid
= parse_pid_to_attach (args
);
657 if (pid
== getpid ())
658 error (_("Attaching GDB to itself is not a good idea..."));
662 exec_file
= (char *) get_exec_file (0);
665 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
666 target_pid_to_str (pid_to_ptid (pid
)));
668 printf_unfiltered ("Attaching to %s\n",
669 target_pid_to_str (pid_to_ptid (pid
)));
671 gdb_flush (gdb_stdout
);
673 inferior_ptid
= do_attach (pid_to_ptid (pid
));
674 inf
= current_inferior ();
675 inferior_appeared (inf
, pid
);
676 inf
->attach_flag
= 1;
678 if (!target_is_pushed (ops
))
681 procfs_update_thread_list (ops
);
685 procfs_post_attach (struct target_ops
*self
, pid_t pid
)
688 solib_create_inferior_hook (0);
692 do_attach (ptid_t ptid
)
694 procfs_status status
;
695 struct sigevent event
;
698 snprintf (path
, PATH_MAX
- 1, "%s%s/%d/as",
699 (nodestr
!= NULL
) ? nodestr
: "", "/proc", ptid_get_pid (ptid
));
700 ctl_fd
= open (path
, O_RDWR
);
702 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
703 safe_strerror (errno
));
704 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
705 error (_("Couldn't stop process"));
707 /* Define a sigevent for process stopped notification. */
708 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
709 event
.sigev_signo
= SIGUSR1
;
710 event
.sigev_code
= 0;
711 event
.sigev_value
.sival_ptr
= NULL
;
712 event
.sigev_priority
= -1;
713 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
715 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
716 && status
.flags
& _DEBUG_FLAG_STOPPED
)
717 SignalKill (nto_node (), ptid_get_pid (ptid
), 0, SIGCONT
, 0, 0);
718 nto_init_solib_absolute_prefix ();
719 return ptid_build (ptid_get_pid (ptid
), 0, status
.tid
);
722 /* Ask the user what to do when an interrupt is received. */
724 interrupt_query (void)
726 if (query (_("Interrupted while waiting for the program.\n\
727 Give up (and stop debugging it)? ")))
729 target_mourn_inferior ();
734 /* The user typed ^C twice. */
736 nto_handle_sigint_twice (int signo
)
738 signal (signo
, ofunc
);
740 signal (signo
, nto_handle_sigint_twice
);
744 nto_handle_sigint (int signo
)
746 /* If this doesn't work, try more severe steps. */
747 signal (signo
, nto_handle_sigint_twice
);
749 target_interrupt (inferior_ptid
);
753 procfs_wait (struct target_ops
*ops
,
754 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
758 procfs_status status
;
759 static int exit_signo
= 0; /* To track signals that cause termination. */
761 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
763 if (ptid_equal (inferior_ptid
, null_ptid
))
765 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
766 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
772 sigaddset (&set
, SIGUSR1
);
774 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
775 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
777 ofunc
= signal (SIGINT
, nto_handle_sigint
);
778 sigwaitinfo (&set
, &info
);
779 signal (SIGINT
, ofunc
);
780 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
783 nto_inferior_data (NULL
)->stopped_flags
= status
.flags
;
784 nto_inferior_data (NULL
)->stopped_pc
= status
.ip
;
786 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
788 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
789 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
791 /* Was it a breakpoint? */
792 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
794 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
795 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
797 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
801 case _DEBUG_WHY_SIGNALLED
:
802 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
803 ourstatus
->value
.sig
=
804 gdb_signal_from_host (status
.info
.si_signo
);
807 case _DEBUG_WHY_FAULTED
:
808 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
809 if (status
.info
.si_signo
== SIGTRAP
)
811 ourstatus
->value
.sig
= 0;
816 ourstatus
->value
.sig
=
817 gdb_signal_from_host (status
.info
.si_signo
);
818 exit_signo
= ourstatus
->value
.sig
;
822 case _DEBUG_WHY_TERMINATED
:
826 waitpid (ptid_get_pid (inferior_ptid
), &waitval
, WNOHANG
);
829 /* Abnormal death. */
830 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
831 ourstatus
->value
.sig
= exit_signo
;
836 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
837 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
843 case _DEBUG_WHY_REQUESTED
:
844 /* We are assuming a requested stop is due to a SIGINT. */
845 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
846 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
852 return ptid_build (status
.pid
, 0, status
.tid
);
855 /* Read the current values of the inferior's registers, both the
856 general register set and floating point registers (if supported)
857 and update gdb's idea of their current values. */
859 procfs_fetch_registers (struct target_ops
*ops
,
860 struct regcache
*regcache
, int regno
)
866 procfs_altreg altreg
;
871 procfs_set_thread (inferior_ptid
);
872 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
873 nto_supply_gregset (regcache
, (char *) ®
.greg
);
874 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
876 nto_supply_fpregset (regcache
, (char *) ®
.fpreg
);
877 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
879 nto_supply_altregset (regcache
, (char *) ®
.altreg
);
882 /* Helper for procfs_xfer_partial that handles memory transfers.
883 Arguments are like target_xfer_partial. */
885 static enum target_xfer_status
886 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
887 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
891 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
892 return TARGET_XFER_E_IO
;
894 if (writebuf
!= NULL
)
895 nbytes
= write (ctl_fd
, writebuf
, len
);
897 nbytes
= read (ctl_fd
, readbuf
, len
);
899 return TARGET_XFER_E_IO
;
900 *xfered_len
= nbytes
;
901 return TARGET_XFER_OK
;
904 /* Target to_xfer_partial implementation. */
906 static enum target_xfer_status
907 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
908 const char *annex
, gdb_byte
*readbuf
,
909 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
910 ULONGEST
*xfered_len
)
914 case TARGET_OBJECT_MEMORY
:
915 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
916 case TARGET_OBJECT_AUXV
:
920 CORE_ADDR initial_stack
;
921 debug_process_t procinfo
;
922 /* For 32-bit architecture, size of auxv_t is 8 bytes. */
923 const unsigned int sizeof_auxv_t
= sizeof (auxv_t
);
924 const unsigned int sizeof_tempbuf
= 20 * sizeof_auxv_t
;
926 gdb_byte
*const tempbuf
= alloca (sizeof_tempbuf
);
929 return TARGET_XFER_E_IO
;
931 err
= devctl (ctl_fd
, DCMD_PROC_INFO
, &procinfo
,
934 return TARGET_XFER_E_IO
;
936 initial_stack
= procinfo
.initial_stack
;
938 /* procfs is always 'self-hosted', no byte-order manipulation. */
939 tempread
= nto_read_auxv_from_initial_stack (initial_stack
, tempbuf
,
942 tempread
= min (tempread
, len
) - offset
;
943 memcpy (readbuf
, tempbuf
+ offset
, tempread
);
944 *xfered_len
= tempread
;
945 return tempread
? TARGET_XFER_OK
: TARGET_XFER_EOF
;
949 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
950 readbuf
, writebuf
, offset
, len
,
955 /* Take a program previously attached to and detaches it.
956 The program resumes execution and will no longer stop
957 on signals, etc. We'd better not have left any breakpoints
958 in the program or it'll die when it hits one. */
960 procfs_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
965 target_announce_detach ();
968 siggnal
= atoi (args
);
971 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, siggnal
, 0, 0);
976 pid
= ptid_get_pid (inferior_ptid
);
977 inferior_ptid
= null_ptid
;
978 detach_inferior (pid
);
980 inf_child_maybe_unpush_target (ops
);
984 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
991 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
998 procfs_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
999 struct bp_target_info
*bp_tgt
)
1001 bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
1002 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, 0);
1006 procfs_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
1007 struct bp_target_info
*bp_tgt
)
1009 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, -1);
1013 procfs_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
1014 struct bp_target_info
*bp_tgt
)
1016 bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
1017 return procfs_breakpoint (bp_tgt
->placed_address
,
1018 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
1022 procfs_remove_hw_breakpoint (struct target_ops
*self
,
1023 struct gdbarch
*gdbarch
,
1024 struct bp_target_info
*bp_tgt
)
1026 return procfs_breakpoint (bp_tgt
->placed_address
,
1027 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
1031 procfs_resume (struct target_ops
*ops
,
1032 ptid_t ptid
, int step
, enum gdb_signal signo
)
1035 procfs_status status
;
1036 sigset_t
*run_fault
= (sigset_t
*) (void *) &run
.fault
;
1038 if (ptid_equal (inferior_ptid
, null_ptid
))
1041 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
1044 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
1046 run
.flags
|= _DEBUG_RUN_STEP
;
1048 sigemptyset (run_fault
);
1049 sigaddset (run_fault
, FLTBPT
);
1050 sigaddset (run_fault
, FLTTRACE
);
1051 sigaddset (run_fault
, FLTILL
);
1052 sigaddset (run_fault
, FLTPRIV
);
1053 sigaddset (run_fault
, FLTBOUNDS
);
1054 sigaddset (run_fault
, FLTIOVF
);
1055 sigaddset (run_fault
, FLTIZDIV
);
1056 sigaddset (run_fault
, FLTFPE
);
1057 /* Peter V will be changing this at some point. */
1058 sigaddset (run_fault
, FLTPAGE
);
1060 run
.flags
|= _DEBUG_RUN_ARM
;
1062 signal_to_pass
= gdb_signal_to_host (signo
);
1066 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
1067 signal_to_pass
= gdb_signal_to_host (signo
);
1068 if (status
.why
& (_DEBUG_WHY_SIGNALLED
| _DEBUG_WHY_FAULTED
))
1070 if (signal_to_pass
!= status
.info
.si_signo
)
1072 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0,
1073 signal_to_pass
, 0, 0);
1074 run
.flags
|= _DEBUG_RUN_CLRFLT
| _DEBUG_RUN_CLRSIG
;
1076 else /* Let it kill the program without telling us. */
1077 sigdelset (&run
.trace
, signal_to_pass
);
1081 run
.flags
|= _DEBUG_RUN_CLRSIG
| _DEBUG_RUN_CLRFLT
;
1083 errno
= devctl (ctl_fd
, DCMD_PROC_RUN
, &run
, sizeof (run
), 0);
1086 perror (_("run error!\n"));
1092 procfs_mourn_inferior (struct target_ops
*ops
)
1094 if (!ptid_equal (inferior_ptid
, null_ptid
))
1096 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, SIGKILL
, 0, 0);
1099 inferior_ptid
= null_ptid
;
1100 init_thread_list ();
1101 inf_child_mourn_inferior (ops
);
1104 /* This function breaks up an argument string into an argument
1105 vector suitable for passing to execvp().
1106 E.g., on "run a b c d" this routine would get as input
1107 the string "a b c d", and as output it would fill in argv with
1108 the four arguments "a", "b", "c", "d". The only additional
1109 functionality is simple quoting. The gdb command:
1111 will fill in argv with the three args "a", "b c d", "e". */
1113 breakup_args (char *scratch
, char **argv
)
1115 char *pp
, *cp
= scratch
;
1120 /* Scan past leading separators. */
1122 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
1125 /* Break if at end of string. */
1133 quoting
= strchr (cp
, '"') ? 1 : 0;
1138 /* Scan for next arg separator. */
1141 cp
= strchr (pp
, '"');
1142 if ((cp
== NULL
) || (!quoting
))
1143 cp
= strchr (pp
, ' ');
1145 cp
= strchr (pp
, '\t');
1147 cp
= strchr (pp
, '\n');
1149 /* No separators => end of string => break. */
1156 /* Replace the separator with a terminator. */
1160 /* Execv requires a null-terminated arg vector. */
1165 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
1166 char *allargs
, char **env
, int from_tty
)
1168 struct inheritance inherit
;
1172 const char *in
= "", *out
= "", *err
= "";
1175 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1176 struct inferior
*inf
;
1178 argv
= xmalloc (((strlen (allargs
) + 1) / (unsigned) 2 + 2) *
1180 argv
[0] = get_exec_file (1);
1184 argv
[0] = exec_file
;
1189 args
= xstrdup (allargs
);
1190 breakup_args (args
, (exec_file
!= NULL
) ? &argv
[1] : &argv
[0]);
1192 argv
= nto_parse_redirection (argv
, &in
, &out
, &err
);
1194 fds
[0] = STDIN_FILENO
;
1195 fds
[1] = STDOUT_FILENO
;
1196 fds
[2] = STDERR_FILENO
;
1198 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1199 if the i/o is not also being specified via redirection. */
1200 if (inferior_io_terminal
)
1203 in
= inferior_io_terminal
;
1205 out
= inferior_io_terminal
;
1207 err
= inferior_io_terminal
;
1212 fd
= open (in
, O_RDONLY
);
1220 fd
= open (out
, O_WRONLY
);
1228 fd
= open (err
, O_WRONLY
);
1235 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1236 signal (SIGUSR1
, signal (SIGUSR1
, SIG_IGN
));
1239 sigaddset (&set
, SIGUSR1
);
1240 sigprocmask (SIG_UNBLOCK
, &set
, NULL
);
1242 memset (&inherit
, 0, sizeof (inherit
));
1244 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) != 0)
1246 inherit
.nd
= nto_node ();
1247 inherit
.flags
|= SPAWN_SETND
;
1248 inherit
.flags
&= ~SPAWN_EXEC
;
1250 inherit
.flags
|= SPAWN_SETGROUP
| SPAWN_HOLD
;
1251 inherit
.pgroup
= SPAWN_NEWPGROUP
;
1252 pid
= spawnp (argv
[0], 3, fds
, &inherit
, argv
,
1253 ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0 ? env
: 0);
1256 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1259 error (_("Error spawning %s: %d (%s)"), argv
[0], errno
,
1260 safe_strerror (errno
));
1262 if (fds
[0] != STDIN_FILENO
)
1264 if (fds
[1] != STDOUT_FILENO
)
1266 if (fds
[2] != STDERR_FILENO
)
1269 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1270 procfs_update_thread_list (ops
);
1272 inf
= current_inferior ();
1273 inferior_appeared (inf
, pid
);
1274 inf
->attach_flag
= 0;
1276 flags
= _DEBUG_FLAG_KLC
; /* Kill-on-Last-Close flag. */
1277 errn
= devctl (ctl_fd
, DCMD_PROC_SET_FLAG
, &flags
, sizeof (flags
), 0);
1280 /* FIXME: expected warning? */
1281 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1282 errn, strerror(errn) ); */
1284 if (!target_is_pushed (ops
))
1286 target_terminal_init ();
1288 if (exec_bfd
!= NULL
1289 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1290 solib_create_inferior_hook (0);
1294 procfs_interrupt (struct target_ops
*self
, ptid_t ptid
)
1296 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1300 procfs_kill_inferior (struct target_ops
*ops
)
1302 target_mourn_inferior ();
1305 /* Fill buf with regset and return devctl cmd to do the setting. Return
1306 -1 if we fail to get the regset. Store size of regset in regsize. */
1308 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1310 int dev_get
, dev_set
;
1313 case NTO_REG_GENERAL
:
1314 dev_get
= DCMD_PROC_GETGREG
;
1315 dev_set
= DCMD_PROC_SETGREG
;
1319 dev_get
= DCMD_PROC_GETFPREG
;
1320 dev_set
= DCMD_PROC_SETFPREG
;
1324 dev_get
= DCMD_PROC_GETALTREG
;
1325 dev_set
= DCMD_PROC_SETALTREG
;
1328 case NTO_REG_SYSTEM
:
1332 if (devctl (ctl_fd
, dev_get
, buf
, bufsize
, regsize
) != EOK
)
1339 procfs_store_registers (struct target_ops
*ops
,
1340 struct regcache
*regcache
, int regno
)
1346 procfs_altreg altreg
;
1350 int len
, regset
, regsize
, dev_set
, err
;
1353 if (ptid_equal (inferior_ptid
, null_ptid
))
1355 procfs_set_thread (inferior_ptid
);
1359 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1361 dev_set
= get_regset (regset
, (char *) ®
,
1362 sizeof (reg
), ®size
);
1366 if (nto_regset_fill (regcache
, regset
, (char *) ®
) == -1)
1369 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1371 fprintf_unfiltered (gdb_stderr
,
1372 "Warning unable to write regset %d: %s\n",
1373 regno
, safe_strerror (err
));
1378 regset
= nto_regset_id (regno
);
1382 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1386 len
= nto_register_area (get_regcache_arch (regcache
),
1387 regno
, regset
, &off
);
1392 regcache_raw_collect (regcache
, regno
, (char *) ®
+ off
);
1394 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1396 fprintf_unfiltered (gdb_stderr
,
1397 "Warning unable to write regset %d: %s\n", regno
,
1398 safe_strerror (err
));
1402 /* Set list of signals to be handled in the target. */
1405 procfs_pass_signals (struct target_ops
*self
,
1406 int numsigs
, unsigned char *pass_signals
)
1410 sigfillset (&run
.trace
);
1412 for (signo
= 1; signo
< NSIG
; signo
++)
1414 int target_signo
= gdb_signal_from_host (signo
);
1415 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
1416 sigdelset (&run
.trace
, signo
);
1421 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1423 static char buf
[1024];
1425 struct tidinfo
*tip
;
1427 pid
= ptid_get_pid (ptid
);
1428 tid
= ptid_get_tid (ptid
);
1430 n
= snprintf (buf
, 1023, "process %d", pid
);
1433 tip
= procfs_thread_info (pid
, tid
);
1435 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1441 /* to_can_run implementation for "target procfs". Note this really
1442 means "can this target be the default run target", which there can
1443 be only one, and we make it be "target native" like other ports.
1444 "target procfs <node>" wouldn't make sense as default run target, as
1448 procfs_can_run (struct target_ops
*self
)
1453 /* "target procfs". */
1454 static struct target_ops nto_procfs_ops
;
1456 /* "target native". */
1457 static struct target_ops
*nto_native_ops
;
1459 /* to_open implementation for "target procfs". */
1462 procfs_open (const char *arg
, int from_tty
)
1464 procfs_open_1 (&nto_procfs_ops
, arg
, from_tty
);
1467 /* to_open implementation for "target native". */
1470 procfs_native_open (const char *arg
, int from_tty
)
1472 procfs_open_1 (nto_native_ops
, arg
, from_tty
);
1475 /* Create the "native" and "procfs" targets. */
1478 init_procfs_targets (void)
1480 struct target_ops
*t
= inf_child_target ();
1482 /* Leave to_shortname as "native". */
1483 t
->to_longname
= "QNX Neutrino local process";
1484 t
->to_doc
= "QNX Neutrino local process (started by the \"run\" command).";
1485 t
->to_open
= procfs_native_open
;
1486 t
->to_attach
= procfs_attach
;
1487 t
->to_post_attach
= procfs_post_attach
;
1488 t
->to_detach
= procfs_detach
;
1489 t
->to_resume
= procfs_resume
;
1490 t
->to_wait
= procfs_wait
;
1491 t
->to_fetch_registers
= procfs_fetch_registers
;
1492 t
->to_store_registers
= procfs_store_registers
;
1493 t
->to_xfer_partial
= procfs_xfer_partial
;
1494 t
->to_files_info
= procfs_files_info
;
1495 t
->to_insert_breakpoint
= procfs_insert_breakpoint
;
1496 t
->to_remove_breakpoint
= procfs_remove_breakpoint
;
1497 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
1498 t
->to_insert_hw_breakpoint
= procfs_insert_hw_breakpoint
;
1499 t
->to_remove_hw_breakpoint
= procfs_remove_hw_breakpoint
;
1500 t
->to_insert_watchpoint
= procfs_insert_hw_watchpoint
;
1501 t
->to_remove_watchpoint
= procfs_remove_hw_watchpoint
;
1502 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
1503 t
->to_kill
= procfs_kill_inferior
;
1504 t
->to_create_inferior
= procfs_create_inferior
;
1505 t
->to_mourn_inferior
= procfs_mourn_inferior
;
1506 t
->to_pass_signals
= procfs_pass_signals
;
1507 t
->to_thread_alive
= procfs_thread_alive
;
1508 t
->to_update_thread_list
= procfs_update_thread_list
;
1509 t
->to_pid_to_str
= procfs_pid_to_str
;
1510 t
->to_interrupt
= procfs_interrupt
;
1511 t
->to_have_continuable_watchpoint
= 1;
1512 t
->to_extra_thread_info
= nto_extra_thread_info
;
1513 t
->to_pid_to_exec_file
= procfs_pid_to_exec_file
;
1517 /* Register "target native". This is the default run target. */
1520 /* Register "target procfs <node>". */
1521 nto_procfs_ops
= *t
;
1522 nto_procfs_ops
.to_shortname
= "procfs";
1523 nto_procfs_ops
.to_can_run
= procfs_can_run
;
1524 t
->to_longname
= "QNX Neutrino local or remote process";
1525 t
->to_doc
= "QNX Neutrino process. target procfs <node>";
1526 t
->to_open
= procfs_open
;
1528 add_target (&nto_procfs_ops
);
1531 #define OSTYPE_NTO 1
1533 extern initialize_file_ftype _initialize_procfs
;
1536 _initialize_procfs (void)
1540 init_procfs_targets ();
1542 /* We use SIGUSR1 to gain control after we block waiting for a process.
1543 We use sigwaitevent to wait. */
1545 sigaddset (&set
, SIGUSR1
);
1546 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1548 /* Initially, make sure all signals are reported. */
1549 sigfillset (&run
.trace
);
1551 /* Stuff some information. */
1552 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1553 nto_cpuinfo_valid
= 1;
1555 add_info ("pidlist", procfs_pidlist
, _("pidlist"));
1556 add_info ("meminfo", procfs_meminfo
, _("memory information"));
1558 nto_is_nto_target
= procfs_is_nto_target
;
1563 procfs_hw_watchpoint (int addr
, int len
, enum target_hw_bp_type type
)
1570 brk
.type
= _DEBUG_BREAK_RD
;
1573 brk
.type
= _DEBUG_BREAK_RW
;
1575 default: /* Modify. */
1576 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1577 brk
.type
= _DEBUG_BREAK_RW
;
1579 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1583 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1586 perror (_("Failed to set hardware watchpoint"));
1593 procfs_can_use_hw_breakpoint (struct target_ops
*self
,
1595 int cnt
, int othertype
)
1601 procfs_remove_hw_watchpoint (struct target_ops
*self
,
1602 CORE_ADDR addr
, int len
,
1603 enum target_hw_bp_type type
,
1604 struct expression
*cond
)
1606 return procfs_hw_watchpoint (addr
, -1, type
);
1610 procfs_insert_hw_watchpoint (struct target_ops
*self
,
1611 CORE_ADDR addr
, int len
,
1612 enum target_hw_bp_type type
,
1613 struct expression
*cond
)
1615 return procfs_hw_watchpoint (addr
, len
, type
);
1619 procfs_stopped_by_watchpoint (struct target_ops
*ops
)
1621 /* NOTE: nto_stopped_by_watchpoint will be called ONLY while we are
1622 stopped due to a SIGTRAP. This assumes gdb works in 'all-stop' mode;
1623 future gdb versions will likely run in 'non-stop' mode in which case
1624 we will have to store/examine statuses per thread in question.
1625 Until then, this will work fine. */
1627 struct inferior
*inf
= current_inferior ();
1628 struct nto_inferior_data
*inf_data
;
1630 gdb_assert (inf
!= NULL
);
1632 inf_data
= nto_inferior_data (inf
);
1634 return inf_data
->stopped_flags
1635 & (_DEBUG_FLAG_TRACE_RD
1636 | _DEBUG_FLAG_TRACE_WR
1637 | _DEBUG_FLAG_TRACE_MODIFY
);