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-2014 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"
45 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
46 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
50 static void (*ofunc
) ();
52 static procfs_run run
;
54 static ptid_t
do_attach (ptid_t ptid
);
56 static int procfs_can_use_hw_breakpoint (struct target_ops
*self
,
59 static int procfs_insert_hw_watchpoint (struct target_ops
*self
,
60 CORE_ADDR addr
, int len
, int type
,
61 struct expression
*cond
);
63 static int procfs_remove_hw_watchpoint (struct target_ops
*self
,
64 CORE_ADDR addr
, int len
, int type
,
65 struct expression
*cond
);
67 static int procfs_stopped_by_watchpoint (struct target_ops
*ops
);
69 /* These two globals are only ever set in procfs_open_1, but are
70 referenced elsewhere. 'nto_procfs_node' is a flag used to say
71 whether we are local, or we should get the current node descriptor
72 for the remote QNX node. */
73 static char nto_procfs_path
[PATH_MAX
] = { "/proc" };
74 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
76 /* Return the current QNX Node, or error out. This is a simple
77 wrapper for the netmgr_strtond() function. The reason this
78 is required is because QNX node descriptors are transient so
79 we have to re-acquire them every time. */
85 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0)
88 node
= netmgr_strtond (nto_procfs_path
, 0);
90 error (_("Lost the QNX node. Debug session probably over."));
96 procfs_is_nto_target (bfd
*abfd
)
98 return GDB_OSABI_QNXNTO
;
101 /* This is called when we call 'target native' or 'target procfs
102 <arg>' from the (gdb) prompt. For QNX6 (nto), the only valid arg
103 will be a QNX node string, eg: "/net/some_node". If arg is not a
104 valid QNX node, we will default to local. */
106 procfs_open_1 (struct target_ops
*ops
, const char *arg
, int from_tty
)
112 procfs_sysinfo
*sysinfo
;
113 struct cleanup
*cleanups
;
115 /* Offer to kill previous inferiors before opening this target. */
116 target_preopen (from_tty
);
118 nto_is_nto_target
= procfs_is_nto_target
;
120 /* Set the default node used for spawning to this one,
121 and only override it if there is a valid arg. */
123 nto_procfs_node
= ND_LOCAL_NODE
;
124 nodestr
= arg
? xstrdup (arg
) : arg
;
130 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
131 if (nto_procfs_node
== -1)
133 if (errno
== ENOTSUP
)
134 printf_filtered ("QNX Net Manager not found.\n");
135 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
136 errno
, safe_strerror (errno
));
139 nto_procfs_node
= ND_LOCAL_NODE
;
143 if (*(endstr
- 1) == '/')
149 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s", nodestr
? nodestr
: "",
154 fd
= open (nto_procfs_path
, O_RDONLY
);
157 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
158 safe_strerror (errno
));
159 error (_("Invalid procfs arg"));
161 cleanups
= make_cleanup_close (fd
);
163 sysinfo
= (void *) buffer
;
164 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, sizeof buffer
, 0) != EOK
)
166 printf_filtered ("Error getting size: %d (%s)\n", errno
,
167 safe_strerror (errno
));
168 error (_("Devctl failed."));
172 total_size
= sysinfo
->total_size
;
173 sysinfo
= alloca (total_size
);
176 printf_filtered ("Memory error: %d (%s)\n", errno
,
177 safe_strerror (errno
));
178 error (_("alloca failed."));
182 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0) != EOK
)
184 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
185 safe_strerror (errno
));
186 error (_("Devctl failed."));
191 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
192 (target_gdbarch ())->arch_name
))
193 error (_("Invalid target CPU."));
197 do_cleanups (cleanups
);
199 inf_child_open_target (ops
, arg
, from_tty
);
200 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
204 procfs_set_thread (ptid_t ptid
)
208 tid
= ptid_get_tid (ptid
);
209 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
212 /* Return nonzero if the thread TH is still alive. */
214 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
218 procfs_status status
;
221 tid
= ptid_get_tid (ptid
);
222 pid
= ptid_get_pid (ptid
);
224 if (kill (pid
, 0) == -1)
228 if ((err
= devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
,
229 &status
, sizeof (status
), 0)) != EOK
)
232 /* Thread is alive or dead but not yet joined,
233 or dead and there is an alive (or dead unjoined) thread with
236 If the tid is not the same as requested, requested tid is dead. */
237 return (status
.tid
== tid
) && (status
.state
!= STATE_DEAD
);
241 update_thread_private_data_name (struct thread_info
*new_thread
,
245 struct private_thread_info
*pti
;
247 gdb_assert (newname
!= NULL
);
248 gdb_assert (new_thread
!= NULL
);
249 newnamelen
= strlen (newname
);
250 if (!new_thread
->private)
252 new_thread
->private = xmalloc (offsetof (struct private_thread_info
,
255 memcpy (new_thread
->private->name
, newname
, newnamelen
+ 1);
257 else if (strcmp (newname
, new_thread
->private->name
) != 0)
259 /* Reallocate if neccessary. */
260 int oldnamelen
= strlen (new_thread
->private->name
);
262 if (oldnamelen
< newnamelen
)
263 new_thread
->private = xrealloc (new_thread
->private,
264 offsetof (struct private_thread_info
,
267 memcpy (new_thread
->private->name
, newname
, newnamelen
+ 1);
272 update_thread_private_data (struct thread_info
*new_thread
,
273 pthread_t tid
, int state
, int flags
)
275 struct private_thread_info
*pti
;
277 struct _thread_name
*tn
;
278 procfs_threadctl tctl
;
280 #if _NTO_VERSION > 630
281 gdb_assert (new_thread
!= NULL
);
283 if (devctl (ctl_fd
, DCMD_PROC_INFO
, &pidinfo
,
284 sizeof(pidinfo
), 0) != EOK
)
287 memset (&tctl
, 0, sizeof (tctl
));
288 tctl
.cmd
= _NTO_TCTL_NAME
;
289 tn
= (struct _thread_name
*) (&tctl
.data
);
291 /* Fetch name for the given thread. */
293 tn
->name_buf_len
= sizeof (tctl
.data
) - sizeof (*tn
);
294 tn
->new_name_len
= -1; /* Getting, not setting. */
295 if (devctl (ctl_fd
, DCMD_PROC_THREADCTL
, &tctl
, sizeof (tctl
), NULL
) != EOK
)
296 tn
->name_buf
[0] = '\0';
298 tn
->name_buf
[_NTO_THREAD_NAME_MAX
] = '\0';
300 update_thread_private_data_name (new_thread
, tn
->name_buf
);
302 pti
= (struct private_thread_info
*) new_thread
->private;
306 #endif /* _NTO_VERSION */
310 procfs_find_new_threads (struct target_ops
*ops
)
312 procfs_status status
;
316 struct thread_info
*new_thread
;
321 pid
= ptid_get_pid (inferior_ptid
);
325 for (tid
= 1;; ++tid
)
327 if (status
.tid
== tid
328 && (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
331 if (status
.tid
!= tid
)
332 /* The reason why this would not be equal is that devctl might have
333 returned different tid, meaning the requested tid no longer exists
334 (e.g. thread exited). */
336 ptid
= ptid_build (pid
, 0, tid
);
337 new_thread
= find_thread_ptid (ptid
);
339 new_thread
= add_thread (ptid
);
340 update_thread_private_data (new_thread
, tid
, status
.state
, 0);
347 do_closedir_cleanup (void *dir
)
353 procfs_pidlist (char *args
, int from_tty
)
356 struct dirent
*dirp
= NULL
;
358 procfs_info
*pidinfo
= NULL
;
359 procfs_debuginfo
*info
= NULL
;
360 procfs_status
*status
= NULL
;
361 pid_t num_threads
= 0;
364 struct cleanup
*cleanups
;
366 dp
= opendir (nto_procfs_path
);
369 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
370 nto_procfs_path
, errno
, safe_strerror (errno
));
374 cleanups
= make_cleanup (do_closedir_cleanup
, dp
);
376 /* Start scan at first pid. */
382 struct cleanup
*inner_cleanup
;
384 /* Get the right pid and procfs path for the pid. */
390 do_cleanups (cleanups
);
393 snprintf (buf
, 511, "%s/%s/as", nto_procfs_path
, dirp
->d_name
);
394 pid
= atoi (dirp
->d_name
);
398 /* Open the procfs path. */
399 fd
= open (buf
, O_RDONLY
);
402 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
403 buf
, errno
, safe_strerror (errno
));
404 do_cleanups (cleanups
);
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
++)
429 if (devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0) != EOK
432 if (status
->tid
!= 0)
433 printf_filtered ("%s - %d/%d\n", name
, pid
, status
->tid
);
436 do_cleanups (inner_cleanup
);
438 while (dirp
!= NULL
);
440 do_cleanups (cleanups
);
445 procfs_meminfo (char *args
, int from_tty
)
447 procfs_mapinfo
*mapinfos
= NULL
;
448 static int num_mapinfos
= 0;
449 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
450 int flags
= ~0, err
, num
, i
, j
;
454 procfs_debuginfo info
;
455 char buff
[_POSIX_PATH_MAX
];
463 unsigned debug_vaddr
;
464 unsigned long long offset
;
469 unsigned long long ino
;
476 /* Get the number of map entrys. */
477 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
480 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
481 safe_strerror (err
));
485 mapinfos
= xmalloc (num
* sizeof (procfs_mapinfo
));
488 mapinfo_p
= mapinfos
;
490 /* Fill the map entrys. */
491 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
492 * sizeof (procfs_mapinfo
), &num
);
495 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
500 num
= min (num
, num_mapinfos
);
502 /* Run through the list of mapinfos, and store the data and text info
503 so we can print it at the bottom of the loop. */
504 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
506 if (!(mapinfo_p
->flags
& flags
))
509 if (mapinfo_p
->ino
== 0) /* Already visited. */
512 map
.info
.vaddr
= mapinfo_p
->vaddr
;
514 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
518 memset (&printme
, 0, sizeof printme
);
519 printme
.dev
= mapinfo_p
->dev
;
520 printme
.ino
= mapinfo_p
->ino
;
521 printme
.text
.addr
= mapinfo_p
->vaddr
;
522 printme
.text
.size
= mapinfo_p
->size
;
523 printme
.text
.flags
= mapinfo_p
->flags
;
524 printme
.text
.offset
= mapinfo_p
->offset
;
525 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
526 strcpy (printme
.name
, map
.info
.path
);
528 /* Check for matching data. */
529 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
531 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
532 && mapinfo_p2
->ino
== mapinfo_p
->ino
533 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
535 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
537 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
541 if (strcmp (map
.info
.path
, printme
.name
))
544 /* Lower debug_vaddr is always text, if nessessary, swap. */
545 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
547 memcpy (&(printme
.data
), &(printme
.text
),
548 sizeof (printme
.data
));
549 printme
.text
.addr
= mapinfo_p2
->vaddr
;
550 printme
.text
.size
= mapinfo_p2
->size
;
551 printme
.text
.flags
= mapinfo_p2
->flags
;
552 printme
.text
.offset
= mapinfo_p2
->offset
;
553 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
557 printme
.data
.addr
= mapinfo_p2
->vaddr
;
558 printme
.data
.size
= mapinfo_p2
->size
;
559 printme
.data
.flags
= mapinfo_p2
->flags
;
560 printme
.data
.offset
= mapinfo_p2
->offset
;
561 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
568 printf_filtered ("%s\n", printme
.name
);
569 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
571 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
572 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
573 printf_filtered ("\t\toffset=%s\n", phex (printme
.text
.offset
, 8));
574 if (printme
.data
.size
)
576 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
578 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
579 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
580 printf_filtered ("\t\toffset=%s\n", phex (printme
.data
.offset
, 8));
582 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
583 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
589 /* Print status information about what we're accessing. */
591 procfs_files_info (struct target_ops
*ignore
)
593 struct inferior
*inf
= current_inferior ();
595 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
596 inf
->attach_flag
? "attached" : "child",
597 target_pid_to_str (inferior_ptid
), nto_procfs_path
);
600 /* Attach to process PID, then initialize for debugging it. */
602 procfs_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
606 struct inferior
*inf
;
608 pid
= parse_pid_to_attach (args
);
610 if (pid
== getpid ())
611 error (_("Attaching GDB to itself is not a good idea..."));
615 exec_file
= (char *) get_exec_file (0);
618 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
619 target_pid_to_str (pid_to_ptid (pid
)));
621 printf_unfiltered ("Attaching to %s\n",
622 target_pid_to_str (pid_to_ptid (pid
)));
624 gdb_flush (gdb_stdout
);
626 inferior_ptid
= do_attach (pid_to_ptid (pid
));
627 inf
= current_inferior ();
628 inferior_appeared (inf
, pid
);
629 inf
->attach_flag
= 1;
631 if (!target_is_pushed (ops
))
634 procfs_find_new_threads (ops
);
638 procfs_post_attach (struct target_ops
*self
, pid_t pid
)
641 solib_create_inferior_hook (0);
645 do_attach (ptid_t ptid
)
647 procfs_status status
;
648 struct sigevent event
;
651 snprintf (path
, PATH_MAX
- 1, "%s/%d/as", nto_procfs_path
,
652 ptid_get_pid (ptid
));
653 ctl_fd
= open (path
, O_RDWR
);
655 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
656 safe_strerror (errno
));
657 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
658 error (_("Couldn't stop process"));
660 /* Define a sigevent for process stopped notification. */
661 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
662 event
.sigev_signo
= SIGUSR1
;
663 event
.sigev_code
= 0;
664 event
.sigev_value
.sival_ptr
= NULL
;
665 event
.sigev_priority
= -1;
666 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
668 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
669 && status
.flags
& _DEBUG_FLAG_STOPPED
)
670 SignalKill (nto_node (), ptid_get_pid (ptid
), 0, SIGCONT
, 0, 0);
671 nto_init_solib_absolute_prefix ();
672 return ptid_build (ptid_get_pid (ptid
), 0, status
.tid
);
675 /* Ask the user what to do when an interrupt is received. */
677 interrupt_query (void)
679 target_terminal_ours ();
681 if (query (_("Interrupted while waiting for the program.\n\
682 Give up (and stop debugging it)? ")))
684 target_mourn_inferior ();
688 target_terminal_inferior ();
691 /* The user typed ^C twice. */
693 nto_interrupt_twice (int signo
)
695 signal (signo
, ofunc
);
697 signal (signo
, nto_interrupt_twice
);
701 nto_interrupt (int signo
)
703 /* If this doesn't work, try more severe steps. */
704 signal (signo
, nto_interrupt_twice
);
706 target_stop (inferior_ptid
);
710 procfs_wait (struct target_ops
*ops
,
711 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
715 procfs_status status
;
716 static int exit_signo
= 0; /* To track signals that cause termination. */
718 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
720 if (ptid_equal (inferior_ptid
, null_ptid
))
722 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
723 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
729 sigaddset (&set
, SIGUSR1
);
731 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
732 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
734 ofunc
= (void (*)()) signal (SIGINT
, nto_interrupt
);
735 sigwaitinfo (&set
, &info
);
736 signal (SIGINT
, ofunc
);
737 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
740 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
742 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
743 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
745 /* Was it a breakpoint? */
746 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
748 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
749 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
751 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
755 case _DEBUG_WHY_SIGNALLED
:
756 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
757 ourstatus
->value
.sig
=
758 gdb_signal_from_host (status
.info
.si_signo
);
761 case _DEBUG_WHY_FAULTED
:
762 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
763 if (status
.info
.si_signo
== SIGTRAP
)
765 ourstatus
->value
.sig
= 0;
770 ourstatus
->value
.sig
=
771 gdb_signal_from_host (status
.info
.si_signo
);
772 exit_signo
= ourstatus
->value
.sig
;
776 case _DEBUG_WHY_TERMINATED
:
780 waitpid (ptid_get_pid (inferior_ptid
), &waitval
, WNOHANG
);
783 /* Abnormal death. */
784 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
785 ourstatus
->value
.sig
= exit_signo
;
790 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
791 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
797 case _DEBUG_WHY_REQUESTED
:
798 /* We are assuming a requested stop is due to a SIGINT. */
799 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
800 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
806 return ptid_build (status
.pid
, 0, status
.tid
);
809 /* Read the current values of the inferior's registers, both the
810 general register set and floating point registers (if supported)
811 and update gdb's idea of their current values. */
813 procfs_fetch_registers (struct target_ops
*ops
,
814 struct regcache
*regcache
, int regno
)
820 procfs_altreg altreg
;
825 procfs_set_thread (inferior_ptid
);
826 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
827 nto_supply_gregset (regcache
, (char *) ®
.greg
);
828 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
830 nto_supply_fpregset (regcache
, (char *) ®
.fpreg
);
831 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
833 nto_supply_altregset (regcache
, (char *) ®
.altreg
);
836 /* Helper for procfs_xfer_partial that handles memory transfers.
837 Arguments are like target_xfer_partial. */
839 static enum target_xfer_status
840 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
841 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
845 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
846 return TARGET_XFER_E_IO
;
848 if (writebuf
!= NULL
)
849 nbytes
= write (ctl_fd
, writebuf
, len
);
851 nbytes
= read (ctl_fd
, readbuf
, len
);
853 return TARGET_XFER_E_IO
;
854 *xfered_len
= nbytes
;
855 return TARGET_XFER_OK
;
858 /* Target to_xfer_partial implementation. */
860 static enum target_xfer_status
861 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
862 const char *annex
, gdb_byte
*readbuf
,
863 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
864 ULONGEST
*xfered_len
)
868 case TARGET_OBJECT_MEMORY
:
869 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
871 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
872 readbuf
, writebuf
, offset
, len
);
876 /* Take a program previously attached to and detaches it.
877 The program resumes execution and will no longer stop
878 on signals, etc. We'd better not have left any breakpoints
879 in the program or it'll die when it hits one. */
881 procfs_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
888 char *exec_file
= get_exec_file (0);
891 printf_unfiltered ("Detaching from program: %s %s\n",
892 exec_file
, target_pid_to_str (inferior_ptid
));
893 gdb_flush (gdb_stdout
);
896 siggnal
= atoi (args
);
899 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, siggnal
, 0, 0);
904 pid
= ptid_get_pid (inferior_ptid
);
905 inferior_ptid
= null_ptid
;
906 detach_inferior (pid
);
908 inf_child_maybe_unpush_target (ops
);
912 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
919 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
926 procfs_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
927 struct bp_target_info
*bp_tgt
)
929 bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
930 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, 0);
934 procfs_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
935 struct bp_target_info
*bp_tgt
)
937 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, -1);
941 procfs_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
942 struct bp_target_info
*bp_tgt
)
944 bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
945 return procfs_breakpoint (bp_tgt
->placed_address
,
946 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, 0);
950 procfs_remove_hw_breakpoint (struct target_ops
*self
,
951 struct gdbarch
*gdbarch
,
952 struct bp_target_info
*bp_tgt
)
954 return procfs_breakpoint (bp_tgt
->placed_address
,
955 _DEBUG_BREAK_EXEC
| _DEBUG_BREAK_HW
, -1);
959 procfs_resume (struct target_ops
*ops
,
960 ptid_t ptid
, int step
, enum gdb_signal signo
)
963 procfs_status status
;
964 sigset_t
*run_fault
= (sigset_t
*) (void *) &run
.fault
;
966 if (ptid_equal (inferior_ptid
, null_ptid
))
969 procfs_set_thread (ptid_equal (ptid
, minus_one_ptid
) ? inferior_ptid
:
972 run
.flags
= _DEBUG_RUN_FAULT
| _DEBUG_RUN_TRACE
;
974 run
.flags
|= _DEBUG_RUN_STEP
;
976 sigemptyset (run_fault
);
977 sigaddset (run_fault
, FLTBPT
);
978 sigaddset (run_fault
, FLTTRACE
);
979 sigaddset (run_fault
, FLTILL
);
980 sigaddset (run_fault
, FLTPRIV
);
981 sigaddset (run_fault
, FLTBOUNDS
);
982 sigaddset (run_fault
, FLTIOVF
);
983 sigaddset (run_fault
, FLTIZDIV
);
984 sigaddset (run_fault
, FLTFPE
);
985 /* Peter V will be changing this at some point. */
986 sigaddset (run_fault
, FLTPAGE
);
988 run
.flags
|= _DEBUG_RUN_ARM
;
990 signal_to_pass
= gdb_signal_to_host (signo
);
994 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
995 signal_to_pass
= gdb_signal_to_host (signo
);
996 if (status
.why
& (_DEBUG_WHY_SIGNALLED
| _DEBUG_WHY_FAULTED
))
998 if (signal_to_pass
!= status
.info
.si_signo
)
1000 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0,
1001 signal_to_pass
, 0, 0);
1002 run
.flags
|= _DEBUG_RUN_CLRFLT
| _DEBUG_RUN_CLRSIG
;
1004 else /* Let it kill the program without telling us. */
1005 sigdelset (&run
.trace
, signal_to_pass
);
1009 run
.flags
|= _DEBUG_RUN_CLRSIG
| _DEBUG_RUN_CLRFLT
;
1011 errno
= devctl (ctl_fd
, DCMD_PROC_RUN
, &run
, sizeof (run
), 0);
1014 perror (_("run error!\n"));
1020 procfs_mourn_inferior (struct target_ops
*ops
)
1022 if (!ptid_equal (inferior_ptid
, null_ptid
))
1024 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, SIGKILL
, 0, 0);
1027 inferior_ptid
= null_ptid
;
1028 init_thread_list ();
1029 inf_child_mourn_inferior (ops
);
1032 /* This function breaks up an argument string into an argument
1033 vector suitable for passing to execvp().
1034 E.g., on "run a b c d" this routine would get as input
1035 the string "a b c d", and as output it would fill in argv with
1036 the four arguments "a", "b", "c", "d". The only additional
1037 functionality is simple quoting. The gdb command:
1039 will fill in argv with the three args "a", "b c d", "e". */
1041 breakup_args (char *scratch
, char **argv
)
1043 char *pp
, *cp
= scratch
;
1048 /* Scan past leading separators. */
1050 while (*cp
== ' ' || *cp
== '\t' || *cp
== '\n')
1053 /* Break if at end of string. */
1061 quoting
= strchr (cp
, '"') ? 1 : 0;
1066 /* Scan for next arg separator. */
1069 cp
= strchr (pp
, '"');
1070 if ((cp
== NULL
) || (!quoting
))
1071 cp
= strchr (pp
, ' ');
1073 cp
= strchr (pp
, '\t');
1075 cp
= strchr (pp
, '\n');
1077 /* No separators => end of string => break. */
1084 /* Replace the separator with a terminator. */
1088 /* Execv requires a null-terminated arg vector. */
1093 procfs_create_inferior (struct target_ops
*ops
, char *exec_file
,
1094 char *allargs
, char **env
, int from_tty
)
1096 struct inheritance inherit
;
1100 const char *in
= "", *out
= "", *err
= "";
1103 const char *inferior_io_terminal
= get_inferior_io_terminal ();
1104 struct inferior
*inf
;
1106 argv
= xmalloc (((strlen (allargs
) + 1) / (unsigned) 2 + 2) *
1108 argv
[0] = get_exec_file (1);
1112 argv
[0] = exec_file
;
1117 args
= xstrdup (allargs
);
1118 breakup_args (args
, exec_file
? &argv
[1] : &argv
[0]);
1120 argv
= nto_parse_redirection (argv
, &in
, &out
, &err
);
1122 fds
[0] = STDIN_FILENO
;
1123 fds
[1] = STDOUT_FILENO
;
1124 fds
[2] = STDERR_FILENO
;
1126 /* If the user specified I/O via gdb's --tty= arg, use it, but only
1127 if the i/o is not also being specified via redirection. */
1128 if (inferior_io_terminal
)
1131 in
= inferior_io_terminal
;
1133 out
= inferior_io_terminal
;
1135 err
= inferior_io_terminal
;
1140 fd
= open (in
, O_RDONLY
);
1148 fd
= open (out
, O_WRONLY
);
1156 fd
= open (err
, O_WRONLY
);
1163 /* Clear any pending SIGUSR1's but keep the behavior the same. */
1164 signal (SIGUSR1
, signal (SIGUSR1
, SIG_IGN
));
1167 sigaddset (&set
, SIGUSR1
);
1168 sigprocmask (SIG_UNBLOCK
, &set
, NULL
);
1170 memset (&inherit
, 0, sizeof (inherit
));
1172 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) != 0)
1174 inherit
.nd
= nto_node ();
1175 inherit
.flags
|= SPAWN_SETND
;
1176 inherit
.flags
&= ~SPAWN_EXEC
;
1178 inherit
.flags
|= SPAWN_SETGROUP
| SPAWN_HOLD
;
1179 inherit
.pgroup
= SPAWN_NEWPGROUP
;
1180 pid
= spawnp (argv
[0], 3, fds
, &inherit
, argv
,
1181 ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0 ? env
: 0);
1184 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1187 error (_("Error spawning %s: %d (%s)"), argv
[0], errno
,
1188 safe_strerror (errno
));
1190 if (fds
[0] != STDIN_FILENO
)
1192 if (fds
[1] != STDOUT_FILENO
)
1194 if (fds
[2] != STDERR_FILENO
)
1197 inferior_ptid
= do_attach (pid_to_ptid (pid
));
1198 procfs_find_new_threads (ops
);
1200 inf
= current_inferior ();
1201 inferior_appeared (inf
, pid
);
1202 inf
->attach_flag
= 0;
1204 flags
= _DEBUG_FLAG_KLC
; /* Kill-on-Last-Close flag. */
1205 errn
= devctl (ctl_fd
, DCMD_PROC_SET_FLAG
, &flags
, sizeof (flags
), 0);
1208 /* FIXME: expected warning? */
1209 /* warning( "Failed to set Kill-on-Last-Close flag: errno = %d(%s)\n",
1210 errn, strerror(errn) ); */
1212 if (!target_is_pushed (ops
))
1214 target_terminal_init ();
1216 if (exec_bfd
!= NULL
1217 || (symfile_objfile
!= NULL
&& symfile_objfile
->obfd
!= NULL
))
1218 solib_create_inferior_hook (0);
1222 procfs_stop (struct target_ops
*self
, ptid_t ptid
)
1224 devctl (ctl_fd
, DCMD_PROC_STOP
, NULL
, 0, 0);
1228 procfs_kill_inferior (struct target_ops
*ops
)
1230 target_mourn_inferior ();
1233 /* Fill buf with regset and return devctl cmd to do the setting. Return
1234 -1 if we fail to get the regset. Store size of regset in regsize. */
1236 get_regset (int regset
, char *buf
, int bufsize
, int *regsize
)
1238 int dev_get
, dev_set
;
1241 case NTO_REG_GENERAL
:
1242 dev_get
= DCMD_PROC_GETGREG
;
1243 dev_set
= DCMD_PROC_SETGREG
;
1247 dev_get
= DCMD_PROC_GETFPREG
;
1248 dev_set
= DCMD_PROC_SETFPREG
;
1252 dev_get
= DCMD_PROC_GETALTREG
;
1253 dev_set
= DCMD_PROC_SETALTREG
;
1256 case NTO_REG_SYSTEM
:
1260 if (devctl (ctl_fd
, dev_get
, buf
, bufsize
, regsize
) != EOK
)
1267 procfs_store_registers (struct target_ops
*ops
,
1268 struct regcache
*regcache
, int regno
)
1274 procfs_altreg altreg
;
1278 int len
, regset
, regsize
, dev_set
, err
;
1281 if (ptid_equal (inferior_ptid
, null_ptid
))
1283 procfs_set_thread (inferior_ptid
);
1287 for (regset
= NTO_REG_GENERAL
; regset
< NTO_REG_END
; regset
++)
1289 dev_set
= get_regset (regset
, (char *) ®
,
1290 sizeof (reg
), ®size
);
1294 if (nto_regset_fill (regcache
, regset
, (char *) ®
) == -1)
1297 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1299 fprintf_unfiltered (gdb_stderr
,
1300 "Warning unable to write regset %d: %s\n",
1301 regno
, safe_strerror (err
));
1306 regset
= nto_regset_id (regno
);
1310 dev_set
= get_regset (regset
, (char *) ®
, sizeof (reg
), ®size
);
1314 len
= nto_register_area (get_regcache_arch (regcache
),
1315 regno
, regset
, &off
);
1320 regcache_raw_collect (regcache
, regno
, (char *) ®
+ off
);
1322 err
= devctl (ctl_fd
, dev_set
, ®
, regsize
, 0);
1324 fprintf_unfiltered (gdb_stderr
,
1325 "Warning unable to write regset %d: %s\n", regno
,
1326 safe_strerror (err
));
1330 /* Set list of signals to be handled in the target. */
1333 procfs_pass_signals (struct target_ops
*self
,
1334 int numsigs
, unsigned char *pass_signals
)
1338 sigfillset (&run
.trace
);
1340 for (signo
= 1; signo
< NSIG
; signo
++)
1342 int target_signo
= gdb_signal_from_host (signo
);
1343 if (target_signo
< numsigs
&& pass_signals
[target_signo
])
1344 sigdelset (&run
.trace
, signo
);
1348 static struct tidinfo
*
1349 procfs_thread_info (pid_t pid
, short tid
)
1356 procfs_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1358 static char buf
[1024];
1360 struct tidinfo
*tip
;
1362 pid
= ptid_get_pid (ptid
);
1363 tid
= ptid_get_tid (ptid
);
1365 n
= snprintf (buf
, 1023, "process %d", pid
);
1368 tip
= procfs_thread_info (pid
, tid
);
1370 snprintf (&buf
[n
], 1023, " (state = 0x%02x)", tip
->state
);
1376 /* to_can_run implementation for "target procfs". Note this really
1377 means "can this target be the default run target", which there can
1378 be only one, and we make it be "target native" like other ports.
1379 "target procfs <node>" wouldn't make sense as default run target, as
1383 procfs_can_run (struct target_ops
*self
)
1388 /* "target procfs". */
1389 static struct target_ops nto_procfs_ops
;
1391 /* "target native". */
1392 static struct target_ops
*nto_native_ops
;
1394 /* to_open implementation for "target procfs". */
1397 procfs_open (const char *arg
, int from_tty
)
1399 procfs_open_1 (&nto_procfs_ops
, arg
, from_tty
);
1402 /* to_open implementation for "target native". */
1405 procfs_native_open (const char *arg
, int from_tty
)
1407 procfs_open_1 (nto_native_ops
, arg
, from_tty
);
1410 /* Create the "native" and "procfs" targets. */
1413 init_procfs_targets (void)
1415 struct target_ops
*t
= inf_child_target ();
1417 /* Leave to_shortname as "native". */
1418 t
->to_longname
= "QNX Neutrino local process";
1419 t
->to_doc
= "QNX Neutrino local process (started by the \"run\" command).";
1420 t
->to_open
= procfs_native_open
;
1421 t
->to_attach
= procfs_attach
;
1422 t
->to_post_attach
= procfs_post_attach
;
1423 t
->to_detach
= procfs_detach
;
1424 t
->to_resume
= procfs_resume
;
1425 t
->to_wait
= procfs_wait
;
1426 t
->to_fetch_registers
= procfs_fetch_registers
;
1427 t
->to_store_registers
= procfs_store_registers
;
1428 t
->to_xfer_partial
= procfs_xfer_partial
;
1429 t
->to_files_info
= procfs_files_info
;
1430 t
->to_insert_breakpoint
= procfs_insert_breakpoint
;
1431 t
->to_remove_breakpoint
= procfs_remove_breakpoint
;
1432 t
->to_can_use_hw_breakpoint
= procfs_can_use_hw_breakpoint
;
1433 t
->to_insert_hw_breakpoint
= procfs_insert_hw_breakpoint
;
1434 t
->to_remove_hw_breakpoint
= procfs_remove_hw_breakpoint
;
1435 t
->to_insert_watchpoint
= procfs_insert_hw_watchpoint
;
1436 t
->to_remove_watchpoint
= procfs_remove_hw_watchpoint
;
1437 t
->to_stopped_by_watchpoint
= procfs_stopped_by_watchpoint
;
1438 t
->to_kill
= procfs_kill_inferior
;
1439 t
->to_create_inferior
= procfs_create_inferior
;
1440 t
->to_mourn_inferior
= procfs_mourn_inferior
;
1441 t
->to_pass_signals
= procfs_pass_signals
;
1442 t
->to_thread_alive
= procfs_thread_alive
;
1443 t
->to_find_new_threads
= procfs_find_new_threads
;
1444 t
->to_pid_to_str
= procfs_pid_to_str
;
1445 t
->to_stop
= procfs_stop
;
1446 t
->to_have_continuable_watchpoint
= 1;
1447 t
->to_extra_thread_info
= nto_extra_thread_info
;
1451 /* Register "target native". This is the default run target. */
1454 /* Register "target procfs <node>". */
1455 nto_procfs_ops
= *t
;
1456 nto_procfs_ops
.to_shortname
= "procfs";
1457 nto_procfs_ops
.to_can_run
= procfs_can_run
;
1458 t
->to_longname
= "QNX Neutrino local or remote process";
1459 t
->to_doc
= "QNX Neutrino process. target procfs <node>";
1460 t
->to_open
= procfs_open
;
1462 add_target (&nto_procfs_ops
);
1465 #define OSTYPE_NTO 1
1468 _initialize_procfs (void)
1472 init_procfs_targets ();
1474 /* We use SIGUSR1 to gain control after we block waiting for a process.
1475 We use sigwaitevent to wait. */
1477 sigaddset (&set
, SIGUSR1
);
1478 sigprocmask (SIG_BLOCK
, &set
, NULL
);
1480 /* Initially, make sure all signals are reported. */
1481 sigfillset (&run
.trace
);
1483 /* Stuff some information. */
1484 nto_cpuinfo_flags
= SYSPAGE_ENTRY (cpuinfo
)->flags
;
1485 nto_cpuinfo_valid
= 1;
1487 add_info ("pidlist", procfs_pidlist
, _("pidlist"));
1488 add_info ("meminfo", procfs_meminfo
, _("memory information"));
1490 nto_is_nto_target
= procfs_is_nto_target
;
1495 procfs_hw_watchpoint (int addr
, int len
, int type
)
1502 brk
.type
= _DEBUG_BREAK_RD
;
1504 case 2: /* Read/Write. */
1505 brk
.type
= _DEBUG_BREAK_RW
;
1507 default: /* Modify. */
1508 /* FIXME: brk.type = _DEBUG_BREAK_RWM gives EINVAL for some reason. */
1509 brk
.type
= _DEBUG_BREAK_RW
;
1511 brk
.type
|= _DEBUG_BREAK_HW
; /* Always ask for HW. */
1515 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
1518 perror (_("Failed to set hardware watchpoint"));
1525 procfs_can_use_hw_breakpoint (struct target_ops
*self
,
1526 int type
, int cnt
, int othertype
)
1532 procfs_remove_hw_watchpoint (struct target_ops
*self
,
1533 CORE_ADDR addr
, int len
, int type
,
1534 struct expression
*cond
)
1536 return procfs_hw_watchpoint (addr
, -1, type
);
1540 procfs_insert_hw_watchpoint (struct target_ops
*self
,
1541 CORE_ADDR addr
, int len
, int type
,
1542 struct expression
*cond
)
1544 return procfs_hw_watchpoint (addr
, len
, type
);
1548 procfs_stopped_by_watchpoint (struct target_ops
*ops
)