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>
34 #include "exceptions.h"
39 #include "gdbthread.h"
44 #include "inf-child.h"
47 #define _DEBUG_FLAG_TRACE (_DEBUG_FLAG_TRACE_EXEC|_DEBUG_FLAG_TRACE_RD|\
48 _DEBUG_FLAG_TRACE_WR|_DEBUG_FLAG_TRACE_MODIFY)
52 static void (*ofunc
) ();
54 static procfs_run run
;
56 static ptid_t
do_attach (ptid_t ptid
);
58 static int procfs_can_use_hw_breakpoint (struct target_ops
*self
,
61 static int procfs_insert_hw_watchpoint (struct target_ops
*self
,
62 CORE_ADDR addr
, int len
, int type
,
63 struct expression
*cond
);
65 static int procfs_remove_hw_watchpoint (struct target_ops
*self
,
66 CORE_ADDR addr
, int len
, int type
,
67 struct expression
*cond
);
69 static int procfs_stopped_by_watchpoint (struct target_ops
*ops
);
71 /* These two globals are only ever set in procfs_open_1, but are
72 referenced elsewhere. 'nto_procfs_node' is a flag used to say
73 whether we are local, or we should get the current node descriptor
74 for the remote QNX node. */
75 static char nto_procfs_path
[PATH_MAX
] = { "/proc" };
76 static unsigned nto_procfs_node
= ND_LOCAL_NODE
;
78 /* Return the current QNX Node, or error out. This is a simple
79 wrapper for the netmgr_strtond() function. The reason this
80 is required is because QNX node descriptors are transient so
81 we have to re-acquire them every time. */
87 if (ND_NODE_CMP (nto_procfs_node
, ND_LOCAL_NODE
) == 0)
90 node
= netmgr_strtond (nto_procfs_path
, 0);
92 error (_("Lost the QNX node. Debug session probably over."));
98 procfs_is_nto_target (bfd
*abfd
)
100 return GDB_OSABI_QNXNTO
;
103 /* This is called when we call 'target native' or 'target procfs
104 <arg>' from the (gdb) prompt. For QNX6 (nto), the only valid arg
105 will be a QNX node string, eg: "/net/some_node". If arg is not a
106 valid QNX node, we will default to local. */
108 procfs_open_1 (struct target_ops
*ops
, const char *arg
, int from_tty
)
114 procfs_sysinfo
*sysinfo
;
115 struct cleanup
*cleanups
;
117 /* Offer to kill previous inferiors before opening this target. */
118 target_preopen (from_tty
);
120 nto_is_nto_target
= procfs_is_nto_target
;
122 /* Set the default node used for spawning to this one,
123 and only override it if there is a valid arg. */
125 nto_procfs_node
= ND_LOCAL_NODE
;
126 nodestr
= arg
? xstrdup (arg
) : arg
;
132 nto_procfs_node
= netmgr_strtond (nodestr
, &endstr
);
133 if (nto_procfs_node
== -1)
135 if (errno
== ENOTSUP
)
136 printf_filtered ("QNX Net Manager not found.\n");
137 printf_filtered ("Invalid QNX node %s: error %d (%s).\n", nodestr
,
138 errno
, safe_strerror (errno
));
141 nto_procfs_node
= ND_LOCAL_NODE
;
145 if (*(endstr
- 1) == '/')
151 snprintf (nto_procfs_path
, PATH_MAX
- 1, "%s%s", nodestr
? nodestr
: "",
156 fd
= open (nto_procfs_path
, O_RDONLY
);
159 printf_filtered ("Error opening %s : %d (%s)\n", nto_procfs_path
, errno
,
160 safe_strerror (errno
));
161 error (_("Invalid procfs arg"));
163 cleanups
= make_cleanup_close (fd
);
165 sysinfo
= (void *) buffer
;
166 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, sizeof buffer
, 0) != EOK
)
168 printf_filtered ("Error getting size: %d (%s)\n", errno
,
169 safe_strerror (errno
));
170 error (_("Devctl failed."));
174 total_size
= sysinfo
->total_size
;
175 sysinfo
= alloca (total_size
);
178 printf_filtered ("Memory error: %d (%s)\n", errno
,
179 safe_strerror (errno
));
180 error (_("alloca failed."));
184 if (devctl (fd
, DCMD_PROC_SYSINFO
, sysinfo
, total_size
, 0) != EOK
)
186 printf_filtered ("Error getting sysinfo: %d (%s)\n", errno
,
187 safe_strerror (errno
));
188 error (_("Devctl failed."));
193 nto_map_arch_to_cputype (gdbarch_bfd_arch_info
194 (target_gdbarch ())->arch_name
))
195 error (_("Invalid target CPU."));
199 do_cleanups (cleanups
);
201 inf_child_open_target (ops
, arg
, from_tty
);
202 printf_filtered ("Debugging using %s\n", nto_procfs_path
);
206 procfs_set_thread (ptid_t ptid
)
210 tid
= ptid_get_tid (ptid
);
211 devctl (ctl_fd
, DCMD_PROC_CURTHREAD
, &tid
, sizeof (tid
), 0);
214 /* Return nonzero if the thread TH is still alive. */
216 procfs_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
220 procfs_status status
;
223 tid
= ptid_get_tid (ptid
);
224 pid
= ptid_get_pid (ptid
);
226 if (kill (pid
, 0) == -1)
230 if ((err
= devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
,
231 &status
, sizeof (status
), 0)) != EOK
)
234 /* Thread is alive or dead but not yet joined,
235 or dead and there is an alive (or dead unjoined) thread with
238 If the tid is not the same as requested, requested tid is dead. */
239 return (status
.tid
== tid
) && (status
.state
!= STATE_DEAD
);
243 update_thread_private_data_name (struct thread_info
*new_thread
,
247 struct private_thread_info
*pti
;
249 gdb_assert (newname
!= NULL
);
250 gdb_assert (new_thread
!= NULL
);
251 newnamelen
= strlen (newname
);
252 if (!new_thread
->private)
254 new_thread
->private = xmalloc (offsetof (struct private_thread_info
,
257 memcpy (new_thread
->private->name
, newname
, newnamelen
+ 1);
259 else if (strcmp (newname
, new_thread
->private->name
) != 0)
261 /* Reallocate if neccessary. */
262 int oldnamelen
= strlen (new_thread
->private->name
);
264 if (oldnamelen
< newnamelen
)
265 new_thread
->private = xrealloc (new_thread
->private,
266 offsetof (struct private_thread_info
,
269 memcpy (new_thread
->private->name
, newname
, newnamelen
+ 1);
274 update_thread_private_data (struct thread_info
*new_thread
,
275 pthread_t tid
, int state
, int flags
)
277 struct private_thread_info
*pti
;
279 struct _thread_name
*tn
;
280 procfs_threadctl tctl
;
282 #if _NTO_VERSION > 630
283 gdb_assert (new_thread
!= NULL
);
285 if (devctl (ctl_fd
, DCMD_PROC_INFO
, &pidinfo
,
286 sizeof(pidinfo
), 0) != EOK
)
289 memset (&tctl
, 0, sizeof (tctl
));
290 tctl
.cmd
= _NTO_TCTL_NAME
;
291 tn
= (struct _thread_name
*) (&tctl
.data
);
293 /* Fetch name for the given thread. */
295 tn
->name_buf_len
= sizeof (tctl
.data
) - sizeof (*tn
);
296 tn
->new_name_len
= -1; /* Getting, not setting. */
297 if (devctl (ctl_fd
, DCMD_PROC_THREADCTL
, &tctl
, sizeof (tctl
), NULL
) != EOK
)
298 tn
->name_buf
[0] = '\0';
300 tn
->name_buf
[_NTO_THREAD_NAME_MAX
] = '\0';
302 update_thread_private_data_name (new_thread
, tn
->name_buf
);
304 pti
= (struct private_thread_info
*) new_thread
->private;
308 #endif /* _NTO_VERSION */
312 procfs_find_new_threads (struct target_ops
*ops
)
314 procfs_status status
;
318 struct thread_info
*new_thread
;
323 pid
= ptid_get_pid (inferior_ptid
);
327 for (tid
= 1;; ++tid
)
329 if (status
.tid
== tid
330 && (devctl (ctl_fd
, DCMD_PROC_TIDSTATUS
, &status
, sizeof (status
), 0)
333 if (status
.tid
!= tid
)
334 /* The reason why this would not be equal is that devctl might have
335 returned different tid, meaning the requested tid no longer exists
336 (e.g. thread exited). */
338 ptid
= ptid_build (pid
, 0, tid
);
339 new_thread
= find_thread_ptid (ptid
);
341 new_thread
= add_thread (ptid
);
342 update_thread_private_data (new_thread
, tid
, status
.state
, 0);
349 do_closedir_cleanup (void *dir
)
355 procfs_pidlist (char *args
, int from_tty
)
358 struct dirent
*dirp
= NULL
;
360 procfs_info
*pidinfo
= NULL
;
361 procfs_debuginfo
*info
= NULL
;
362 procfs_status
*status
= NULL
;
363 pid_t num_threads
= 0;
366 struct cleanup
*cleanups
;
368 dp
= opendir (nto_procfs_path
);
371 fprintf_unfiltered (gdb_stderr
, "failed to opendir \"%s\" - %d (%s)",
372 nto_procfs_path
, errno
, safe_strerror (errno
));
376 cleanups
= make_cleanup (do_closedir_cleanup
, dp
);
378 /* Start scan at first pid. */
384 struct cleanup
*inner_cleanup
;
386 /* Get the right pid and procfs path for the pid. */
392 do_cleanups (cleanups
);
395 snprintf (buf
, 511, "%s/%s/as", nto_procfs_path
, dirp
->d_name
);
396 pid
= atoi (dirp
->d_name
);
400 /* Open the procfs path. */
401 fd
= open (buf
, O_RDONLY
);
404 fprintf_unfiltered (gdb_stderr
, "failed to open %s - %d (%s)\n",
405 buf
, errno
, safe_strerror (errno
));
406 do_cleanups (cleanups
);
409 inner_cleanup
= make_cleanup_close (fd
);
411 pidinfo
= (procfs_info
*) buf
;
412 if (devctl (fd
, DCMD_PROC_INFO
, pidinfo
, sizeof (buf
), 0) != EOK
)
414 fprintf_unfiltered (gdb_stderr
,
415 "devctl DCMD_PROC_INFO failed - %d (%s)\n",
416 errno
, safe_strerror (errno
));
419 num_threads
= pidinfo
->num_threads
;
421 info
= (procfs_debuginfo
*) buf
;
422 if (devctl (fd
, DCMD_PROC_MAPDEBUG_BASE
, info
, sizeof (buf
), 0) != EOK
)
423 strcpy (name
, "unavailable");
425 strcpy (name
, info
->path
);
427 /* Collect state info on all the threads. */
428 status
= (procfs_status
*) buf
;
429 for (status
->tid
= 1; status
->tid
<= num_threads
; status
->tid
++)
431 if (devctl (fd
, DCMD_PROC_TIDSTATUS
, status
, sizeof (buf
), 0) != EOK
434 if (status
->tid
!= 0)
435 printf_filtered ("%s - %d/%d\n", name
, pid
, status
->tid
);
438 do_cleanups (inner_cleanup
);
440 while (dirp
!= NULL
);
442 do_cleanups (cleanups
);
447 procfs_meminfo (char *args
, int from_tty
)
449 procfs_mapinfo
*mapinfos
= NULL
;
450 static int num_mapinfos
= 0;
451 procfs_mapinfo
*mapinfo_p
, *mapinfo_p2
;
452 int flags
= ~0, err
, num
, i
, j
;
456 procfs_debuginfo info
;
457 char buff
[_POSIX_PATH_MAX
];
465 unsigned debug_vaddr
;
466 unsigned long long offset
;
471 unsigned long long ino
;
478 /* Get the number of map entrys. */
479 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, NULL
, 0, &num
);
482 printf ("failed devctl num mapinfos - %d (%s)\n", err
,
483 safe_strerror (err
));
487 mapinfos
= xmalloc (num
* sizeof (procfs_mapinfo
));
490 mapinfo_p
= mapinfos
;
492 /* Fill the map entrys. */
493 err
= devctl (ctl_fd
, DCMD_PROC_MAPINFO
, mapinfo_p
, num
494 * sizeof (procfs_mapinfo
), &num
);
497 printf ("failed devctl mapinfos - %d (%s)\n", err
, safe_strerror (err
));
502 num
= min (num
, num_mapinfos
);
504 /* Run through the list of mapinfos, and store the data and text info
505 so we can print it at the bottom of the loop. */
506 for (mapinfo_p
= mapinfos
, i
= 0; i
< num
; i
++, mapinfo_p
++)
508 if (!(mapinfo_p
->flags
& flags
))
511 if (mapinfo_p
->ino
== 0) /* Already visited. */
514 map
.info
.vaddr
= mapinfo_p
->vaddr
;
516 err
= devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
520 memset (&printme
, 0, sizeof printme
);
521 printme
.dev
= mapinfo_p
->dev
;
522 printme
.ino
= mapinfo_p
->ino
;
523 printme
.text
.addr
= mapinfo_p
->vaddr
;
524 printme
.text
.size
= mapinfo_p
->size
;
525 printme
.text
.flags
= mapinfo_p
->flags
;
526 printme
.text
.offset
= mapinfo_p
->offset
;
527 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
528 strcpy (printme
.name
, map
.info
.path
);
530 /* Check for matching data. */
531 for (mapinfo_p2
= mapinfos
, j
= 0; j
< num
; j
++, mapinfo_p2
++)
533 if (mapinfo_p2
->vaddr
!= mapinfo_p
->vaddr
534 && mapinfo_p2
->ino
== mapinfo_p
->ino
535 && mapinfo_p2
->dev
== mapinfo_p
->dev
)
537 map
.info
.vaddr
= mapinfo_p2
->vaddr
;
539 devctl (ctl_fd
, DCMD_PROC_MAPDEBUG
, &map
, sizeof (map
), 0);
543 if (strcmp (map
.info
.path
, printme
.name
))
546 /* Lower debug_vaddr is always text, if nessessary, swap. */
547 if ((int) map
.info
.vaddr
< (int) printme
.text
.debug_vaddr
)
549 memcpy (&(printme
.data
), &(printme
.text
),
550 sizeof (printme
.data
));
551 printme
.text
.addr
= mapinfo_p2
->vaddr
;
552 printme
.text
.size
= mapinfo_p2
->size
;
553 printme
.text
.flags
= mapinfo_p2
->flags
;
554 printme
.text
.offset
= mapinfo_p2
->offset
;
555 printme
.text
.debug_vaddr
= map
.info
.vaddr
;
559 printme
.data
.addr
= mapinfo_p2
->vaddr
;
560 printme
.data
.size
= mapinfo_p2
->size
;
561 printme
.data
.flags
= mapinfo_p2
->flags
;
562 printme
.data
.offset
= mapinfo_p2
->offset
;
563 printme
.data
.debug_vaddr
= map
.info
.vaddr
;
570 printf_filtered ("%s\n", printme
.name
);
571 printf_filtered ("\ttext=%08x bytes @ 0x%08x\n", printme
.text
.size
,
573 printf_filtered ("\t\tflags=%08x\n", printme
.text
.flags
);
574 printf_filtered ("\t\tdebug=%08x\n", printme
.text
.debug_vaddr
);
575 printf_filtered ("\t\toffset=%s\n", phex (printme
.text
.offset
, 8));
576 if (printme
.data
.size
)
578 printf_filtered ("\tdata=%08x bytes @ 0x%08x\n", printme
.data
.size
,
580 printf_filtered ("\t\tflags=%08x\n", printme
.data
.flags
);
581 printf_filtered ("\t\tdebug=%08x\n", printme
.data
.debug_vaddr
);
582 printf_filtered ("\t\toffset=%s\n", phex (printme
.data
.offset
, 8));
584 printf_filtered ("\tdev=0x%x\n", printme
.dev
);
585 printf_filtered ("\tino=0x%x\n", (unsigned int) printme
.ino
);
591 /* Print status information about what we're accessing. */
593 procfs_files_info (struct target_ops
*ignore
)
595 struct inferior
*inf
= current_inferior ();
597 printf_unfiltered ("\tUsing the running image of %s %s via %s.\n",
598 inf
->attach_flag
? "attached" : "child",
599 target_pid_to_str (inferior_ptid
), nto_procfs_path
);
602 /* Attach to process PID, then initialize for debugging it. */
604 procfs_attach (struct target_ops
*ops
, const char *args
, int from_tty
)
608 struct inferior
*inf
;
610 pid
= parse_pid_to_attach (args
);
612 if (pid
== getpid ())
613 error (_("Attaching GDB to itself is not a good idea..."));
617 exec_file
= (char *) get_exec_file (0);
620 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
621 target_pid_to_str (pid_to_ptid (pid
)));
623 printf_unfiltered ("Attaching to %s\n",
624 target_pid_to_str (pid_to_ptid (pid
)));
626 gdb_flush (gdb_stdout
);
628 inferior_ptid
= do_attach (pid_to_ptid (pid
));
629 inf
= current_inferior ();
630 inferior_appeared (inf
, pid
);
631 inf
->attach_flag
= 1;
633 if (!target_is_pushed (ops
))
636 procfs_find_new_threads (ops
);
640 procfs_post_attach (struct target_ops
*self
, pid_t pid
)
643 solib_create_inferior_hook (0);
647 do_attach (ptid_t ptid
)
649 procfs_status status
;
650 struct sigevent event
;
653 snprintf (path
, PATH_MAX
- 1, "%s/%d/as", nto_procfs_path
,
654 ptid_get_pid (ptid
));
655 ctl_fd
= open (path
, O_RDWR
);
657 error (_("Couldn't open proc file %s, error %d (%s)"), path
, errno
,
658 safe_strerror (errno
));
659 if (devctl (ctl_fd
, DCMD_PROC_STOP
, &status
, sizeof (status
), 0) != EOK
)
660 error (_("Couldn't stop process"));
662 /* Define a sigevent for process stopped notification. */
663 event
.sigev_notify
= SIGEV_SIGNAL_THREAD
;
664 event
.sigev_signo
= SIGUSR1
;
665 event
.sigev_code
= 0;
666 event
.sigev_value
.sival_ptr
= NULL
;
667 event
.sigev_priority
= -1;
668 devctl (ctl_fd
, DCMD_PROC_EVENT
, &event
, sizeof (event
), 0);
670 if (devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0) == EOK
671 && status
.flags
& _DEBUG_FLAG_STOPPED
)
672 SignalKill (nto_node (), ptid_get_pid (ptid
), 0, SIGCONT
, 0, 0);
673 nto_init_solib_absolute_prefix ();
674 return ptid_build (ptid_get_pid (ptid
), 0, status
.tid
);
677 /* Ask the user what to do when an interrupt is received. */
679 interrupt_query (void)
681 target_terminal_ours ();
683 if (query (_("Interrupted while waiting for the program.\n\
684 Give up (and stop debugging it)? ")))
686 target_mourn_inferior ();
690 target_terminal_inferior ();
693 /* The user typed ^C twice. */
695 nto_interrupt_twice (int signo
)
697 signal (signo
, ofunc
);
699 signal (signo
, nto_interrupt_twice
);
703 nto_interrupt (int signo
)
705 /* If this doesn't work, try more severe steps. */
706 signal (signo
, nto_interrupt_twice
);
708 target_stop (inferior_ptid
);
712 procfs_wait (struct target_ops
*ops
,
713 ptid_t ptid
, struct target_waitstatus
*ourstatus
, int options
)
717 procfs_status status
;
718 static int exit_signo
= 0; /* To track signals that cause termination. */
720 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
722 if (ptid_equal (inferior_ptid
, null_ptid
))
724 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
725 ourstatus
->value
.sig
= GDB_SIGNAL_0
;
731 sigaddset (&set
, SIGUSR1
);
733 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
734 while (!(status
.flags
& _DEBUG_FLAG_ISTOP
))
736 ofunc
= (void (*)()) signal (SIGINT
, nto_interrupt
);
737 sigwaitinfo (&set
, &info
);
738 signal (SIGINT
, ofunc
);
739 devctl (ctl_fd
, DCMD_PROC_STATUS
, &status
, sizeof (status
), 0);
742 if (status
.flags
& _DEBUG_FLAG_SSTEP
)
744 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
745 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
747 /* Was it a breakpoint? */
748 else if (status
.flags
& _DEBUG_FLAG_TRACE
)
750 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
751 ourstatus
->value
.sig
= GDB_SIGNAL_TRAP
;
753 else if (status
.flags
& _DEBUG_FLAG_ISTOP
)
757 case _DEBUG_WHY_SIGNALLED
:
758 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
759 ourstatus
->value
.sig
=
760 gdb_signal_from_host (status
.info
.si_signo
);
763 case _DEBUG_WHY_FAULTED
:
764 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
765 if (status
.info
.si_signo
== SIGTRAP
)
767 ourstatus
->value
.sig
= 0;
772 ourstatus
->value
.sig
=
773 gdb_signal_from_host (status
.info
.si_signo
);
774 exit_signo
= ourstatus
->value
.sig
;
778 case _DEBUG_WHY_TERMINATED
:
782 waitpid (ptid_get_pid (inferior_ptid
), &waitval
, WNOHANG
);
785 /* Abnormal death. */
786 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
787 ourstatus
->value
.sig
= exit_signo
;
792 ourstatus
->kind
= TARGET_WAITKIND_EXITED
;
793 ourstatus
->value
.integer
= WEXITSTATUS (waitval
);
799 case _DEBUG_WHY_REQUESTED
:
800 /* We are assuming a requested stop is due to a SIGINT. */
801 ourstatus
->kind
= TARGET_WAITKIND_STOPPED
;
802 ourstatus
->value
.sig
= GDB_SIGNAL_INT
;
808 return ptid_build (status
.pid
, 0, status
.tid
);
811 /* Read the current values of the inferior's registers, both the
812 general register set and floating point registers (if supported)
813 and update gdb's idea of their current values. */
815 procfs_fetch_registers (struct target_ops
*ops
,
816 struct regcache
*regcache
, int regno
)
822 procfs_altreg altreg
;
827 procfs_set_thread (inferior_ptid
);
828 if (devctl (ctl_fd
, DCMD_PROC_GETGREG
, ®
, sizeof (reg
), ®size
) == EOK
)
829 nto_supply_gregset (regcache
, (char *) ®
.greg
);
830 if (devctl (ctl_fd
, DCMD_PROC_GETFPREG
, ®
, sizeof (reg
), ®size
)
832 nto_supply_fpregset (regcache
, (char *) ®
.fpreg
);
833 if (devctl (ctl_fd
, DCMD_PROC_GETALTREG
, ®
, sizeof (reg
), ®size
)
835 nto_supply_altregset (regcache
, (char *) ®
.altreg
);
838 /* Helper for procfs_xfer_partial that handles memory transfers.
839 Arguments are like target_xfer_partial. */
841 static enum target_xfer_status
842 procfs_xfer_memory (gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
843 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
847 if (lseek (ctl_fd
, (off_t
) memaddr
, SEEK_SET
) != (off_t
) memaddr
)
848 return TARGET_XFER_E_IO
;
850 if (writebuf
!= NULL
)
851 nbytes
= write (ctl_fd
, writebuf
, len
);
853 nbytes
= read (ctl_fd
, readbuf
, len
);
855 return TARGET_XFER_E_IO
;
856 *xfered_len
= nbytes
;
857 return TARGET_XFER_OK
;
860 /* Target to_xfer_partial implementation. */
862 static enum target_xfer_status
863 procfs_xfer_partial (struct target_ops
*ops
, enum target_object object
,
864 const char *annex
, gdb_byte
*readbuf
,
865 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
866 ULONGEST
*xfered_len
)
870 case TARGET_OBJECT_MEMORY
:
871 return procfs_xfer_memory (readbuf
, writebuf
, offset
, len
, xfered_len
);
873 return ops
->beneath
->to_xfer_partial (ops
->beneath
, object
, annex
,
874 readbuf
, writebuf
, offset
, len
);
878 /* Take a program previously attached to and detaches it.
879 The program resumes execution and will no longer stop
880 on signals, etc. We'd better not have left any breakpoints
881 in the program or it'll die when it hits one. */
883 procfs_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
890 char *exec_file
= get_exec_file (0);
893 printf_unfiltered ("Detaching from program: %s %s\n",
894 exec_file
, target_pid_to_str (inferior_ptid
));
895 gdb_flush (gdb_stdout
);
898 siggnal
= atoi (args
);
901 SignalKill (nto_node (), ptid_get_pid (inferior_ptid
), 0, siggnal
, 0, 0);
906 pid
= ptid_get_pid (inferior_ptid
);
907 inferior_ptid
= null_ptid
;
908 detach_inferior (pid
);
910 inf_child_maybe_unpush_target (ops
);
914 procfs_breakpoint (CORE_ADDR addr
, int type
, int size
)
921 errno
= devctl (ctl_fd
, DCMD_PROC_BREAK
, &brk
, sizeof (brk
), 0);
928 procfs_insert_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
929 struct bp_target_info
*bp_tgt
)
931 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, 0);
935 procfs_remove_breakpoint (struct target_ops
*ops
, struct gdbarch
*gdbarch
,
936 struct bp_target_info
*bp_tgt
)
938 return procfs_breakpoint (bp_tgt
->placed_address
, _DEBUG_BREAK_EXEC
, -1);
942 procfs_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
943 struct bp_target_info
*bp_tgt
)
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
)